@funnycode/myclaude 0.1.69 → 0.1.71

package/seed/marketplaces/ecc/skills/tinystruct-patterns/references/data-handling.md

@@ -1,60 +1,60 @@
-# tinystruct Data Handling (JSON)
-
-## When to Use
-
-Prefer `org.tinystruct.data.component.Builder` and `Builders` for lightweight, zero-dependency JSON. Use `Builder` for JSON objects (`{}`), `Builders` for JSON arrays (`[]`). **Always use `Builders` instead of `List<Builder>`** to avoid generic type erasure issues.
-
-## How It Works
-
-`Builder` provides a key-value interface for creating and reading JSON objects. `Builders` provides an indexed list for JSON arrays. Both integrate directly with `AbstractApplication` result handling.
-
-### Why Builder/Builders?
-- **Zero External Dependencies** — lean and fast
-- **Native Integration** — works with framework result handling
-- **Type Safety** — `Builders` serializes properly to `[]`; `List<Builder>` can cause casting issues
-
-## Examples
-
-### Serialize a Single Object
-```java
-import org.tinystruct.data.component.Builder;
-
-Builder response = new Builder();
-response.put("status", "success");
-response.put("count", 42);
-return response.toString(); // {"status":"success","count":42}
-```
-
-### Serialize a List using Builders
-```java
-import org.tinystruct.data.component.Builder;
-import org.tinystruct.data.component.Builders;
-
-Builders dataList = new Builders();
-for (MyModel item : myCollection) {
-    Builder b = new Builder();
-    b.put("id", item.getId());
-    b.put("name", item.getName());
-    dataList.add(b);
-}
-Builder response = new Builder();
-response.put("data", dataList);
-return response.toString(); // {"data":[{"id":1,"name":"X"}]}
-```
-
-### Parse a JSON Object
-```java
-Builder parsed = new Builder();
-parsed.parse(jsonString);
-String status = parsed.get("status").toString();
-```
-
-### Parse a JSON Array
-```java
-Builders parsedArray = new Builders();
-parsedArray.parse(jsonArrayString);
-for (int i = 0; i < parsedArray.size(); i++) {
-    Builder item = parsedArray.get(i);
-    System.out.println(item.get("name"));
-}
-```
+# tinystruct Data Handling (JSON)
+
+## When to Use
+
+Prefer `org.tinystruct.data.component.Builder` and `Builders` for lightweight, zero-dependency JSON. Use `Builder` for JSON objects (`{}`), `Builders` for JSON arrays (`[]`). **Always use `Builders` instead of `List<Builder>`** to avoid generic type erasure issues.
+
+## How It Works
+
+`Builder` provides a key-value interface for creating and reading JSON objects. `Builders` provides an indexed list for JSON arrays. Both integrate directly with `AbstractApplication` result handling.
+
+### Why Builder/Builders?
+- **Zero External Dependencies** — lean and fast
+- **Native Integration** — works with framework result handling
+- **Type Safety** — `Builders` serializes properly to `[]`; `List<Builder>` can cause casting issues
+
+## Examples
+
+### Serialize a Single Object
+```java
+import org.tinystruct.data.component.Builder;
+
+Builder response = new Builder();
+response.put("status", "success");
+response.put("count", 42);
+return response.toString(); // {"status":"success","count":42}
+```
+
+### Serialize a List using Builders
+```java
+import org.tinystruct.data.component.Builder;
+import org.tinystruct.data.component.Builders;
+
+Builders dataList = new Builders();
+for (MyModel item : myCollection) {
+    Builder b = new Builder();
+    b.put("id", item.getId());
+    b.put("name", item.getName());
+    dataList.add(b);
+}
+Builder response = new Builder();
+response.put("data", dataList);
+return response.toString(); // {"data":[{"id":1,"name":"X"}]}
+```
+
+### Parse a JSON Object
+```java
+Builder parsed = new Builder();
+parsed.parse(jsonString);
+String status = parsed.get("status").toString();
+```
+
+### Parse a JSON Array
+```java
+Builders parsedArray = new Builders();
+parsedArray.parse(jsonArrayString);
+for (int i = 0; i < parsedArray.size(); i++) {
+    Builder item = parsedArray.get(i);
+    System.out.println(item.get("name"));
+}
+```

package/seed/marketplaces/ecc/skills/tinystruct-patterns/references/database.md

@@ -1,99 +1,99 @@
-# tinystruct Database Persistence
-
-## When to Use
-
-Use the built-in ORM-like data layer for database operations. It provides a lightweight alternative to JPA/Hibernate using POJOs extending `AbstractData` and XML mapping files.
-
-## How It Works
-
-### Architecture
-
-Each table is represented by:
-1. **Java POJO**: Extends `AbstractData`, provides getters/setters and `setData(Row)`.
-2. **Mapping XML**: `ClassName.map.xml` in resources, binding Java fields to DB columns.
-
-#### Key Base Class: `AbstractData`
-Provides CRUD methods:
-- `append()` / `appendAndGetId()`
-- `update()`
-- `delete()`
-- `findAll()` / `findOneById()` / `findOneByKey(key, value)`
-- `findWith(where, params)`
-- `find(SQL, params)`
-
-### POJO Generation (CLI)
-
-Introspect a live database table to produce the POJO and mapping file.
-
-#### Configuration
-`application.properties`:
-```properties
-driver=com.mysql.cj.jdbc.Driver
-database.url=jdbc:mysql://localhost:3306/mydb
-database.user=root
-database.password=secret
-```
-
-#### Command
-```bash
-# Interactive mode
-bin/dispatcher generate
-
-# Specify table
-bin/dispatcher generate --tables users
-```
-
-## Examples
-
-### CRUD Operations
-```java
-// CREATE
-User user = new User();
-user.setUsername("james");
-user.append();
-
-// READ
-User user = new User();
-user.setId(42);
-user.findOneById();
-
-// UPDATE
-user.setEmail("new@example.com");
-user.update();
-
-// DELETE
-user.delete();
-```
-
-### Querying with Conditions
-```java
-User user = new User();
-Table results = user.findWith("username LIKE ?", new Object[]{"%jam%"});
-
-// Fluent Condition Builder
-Condition condition = new Condition();
-condition.setRequestFields("id,username");
-Table filtered = user.find(
-    condition.select("`users`").and("email LIKE ?").orderBy("id DESC"),
-    new Object[]{"%@example.com"}
-);
-```
-
-### Mapping XML Structure
-`User.map.xml`:
-```xml
-<mapping>
-  <class name="User" table="users">
-    <id name="Id" column="id" increment="true" generate="false" length="11" type="int"/>
-    <property name="username" column="username" length="50" type="varchar"/>
-    <property name="email" column="email" length="100" type="varchar"/>
-  </class>
-</mapping>
-```
-
-## Important Rules
-
-1. **File Placement**: The mapping XML **must** mirror the POJO's package path under `src/main/resources/`.
-2. **Naming**: Table names are singularized for class names (`users` → `User`). Underscored columns become camelCase fields (`created_at` → `createdAt`).
-3. **Setters**: Use `setFieldAsXxx` methods (e.g., `setFieldAsString`) in setters to sync state with the internal field map.
-4. **Id Field**: The primary key field in Java is always named `Id` (inherited from `AbstractData`).
+# tinystruct Database Persistence
+
+## When to Use
+
+Use the built-in ORM-like data layer for database operations. It provides a lightweight alternative to JPA/Hibernate using POJOs extending `AbstractData` and XML mapping files.
+
+## How It Works
+
+### Architecture
+
+Each table is represented by:
+1. **Java POJO**: Extends `AbstractData`, provides getters/setters and `setData(Row)`.
+2. **Mapping XML**: `ClassName.map.xml` in resources, binding Java fields to DB columns.
+
+#### Key Base Class: `AbstractData`
+Provides CRUD methods:
+- `append()` / `appendAndGetId()`
+- `update()`
+- `delete()`
+- `findAll()` / `findOneById()` / `findOneByKey(key, value)`
+- `findWith(where, params)`
+- `find(SQL, params)`
+
+### POJO Generation (CLI)
+
+Introspect a live database table to produce the POJO and mapping file.
+
+#### Configuration
+`application.properties`:
+```properties
+driver=com.mysql.cj.jdbc.Driver
+database.url=jdbc:mysql://localhost:3306/mydb
+database.user=root
+database.password=secret
+```
+
+#### Command
+```bash
+# Interactive mode
+bin/dispatcher generate
+
+# Specify table
+bin/dispatcher generate --tables users
+```
+
+## Examples
+
+### CRUD Operations
+```java
+// CREATE
+User user = new User();
+user.setUsername("james");
+user.append();
+
+// READ
+User user = new User();
+user.setId(42);
+user.findOneById();
+
+// UPDATE
+user.setEmail("new@example.com");
+user.update();
+
+// DELETE
+user.delete();
+```
+
+### Querying with Conditions
+```java
+User user = new User();
+Table results = user.findWith("username LIKE ?", new Object[]{"%jam%"});
+
+// Fluent Condition Builder
+Condition condition = new Condition();
+condition.setRequestFields("id,username");
+Table filtered = user.find(
+    condition.select("`users`").and("email LIKE ?").orderBy("id DESC"),
+    new Object[]{"%@example.com"}
+);
+```
+
+### Mapping XML Structure
+`User.map.xml`:
+```xml
+<mapping>
+  <class name="User" table="users">
+    <id name="Id" column="id" increment="true" generate="false" length="11" type="int"/>
+    <property name="username" column="username" length="50" type="varchar"/>
+    <property name="email" column="email" length="100" type="varchar"/>
+  </class>
+</mapping>
+```
+
+## Important Rules
+
+1. **File Placement**: The mapping XML **must** mirror the POJO's package path under `src/main/resources/`.
+2. **Naming**: Table names are singularized for class names (`users` → `User`). Underscored columns become camelCase fields (`created_at` → `createdAt`).
+3. **Setters**: Use `setFieldAsXxx` methods (e.g., `setFieldAsString`) in setters to sync state with the internal field map.
+4. **Id Field**: The primary key field in Java is always named `Id` (inherited from `AbstractData`).

package/seed/marketplaces/ecc/skills/tinystruct-patterns/references/routing.md

@@ -1,64 +1,64 @@
-# tinystruct @Action Routing Reference
-
-## When to Use
-
-Use the `@Action` annotation in your applications to define routes for both CLI commands and HTTP endpoints. It is appropriate whenever you need to map logic to a specific path, handle parameterized requests, or restrict execution to specific HTTP methods while maintaining a consistent command structure across environments.
-
-## How It Works
-
-The `ActionRegistry` parses `@Action` annotations to build a routing table. For parameterized methods, the framework automatically maps Java parameter types to corresponding regex segments.
-
-### Regex Generation Rules
-- `getUser(int id)` → pattern: `^/?user/(-?\d+)$`
-- `search(String query)` → pattern: `^/?search/([^/]+)$`
-
-Supported parameter types: `String`, `int/Integer`, `long/Long`, `float/Float`, `double/Double`, `boolean/Boolean`, `char/Character`, `short/Short`, `byte/Byte`, `Date` (parsed as `yyyy-MM-dd HH:mm:ss`).
-
-### Mode Values
-
-| Mode | When it triggers |
-|---|---|
-| `DEFAULT` | Both CLI and HTTP (GET, POST, etc.) |
-| `CLI` | CLI dispatcher only |
-| `HTTP_GET` | HTTP GET only |
-| `HTTP_POST` | HTTP POST only |
-| `HTTP_PUT` | HTTP PUT only |
-| `HTTP_DELETE` | HTTP DELETE only |
-| `HTTP_PATCH` | HTTP PATCH only |
-
-> **Note:** You can map HTTP method names to `Mode` using `Action.Mode.fromName(String methodName)`. Unknown or null values return `Mode.DEFAULT`.
-
-## Examples
-
-### Basic Action Declaration
-```java
-@Action(
-    value = "path/subpath",          // required: URI segment or CLI command
-    description = "What it does",    // shown in --help output
-    mode = Mode.DEFAULT,             // default: Mode.DEFAULT
-    example = "bin/dispatcher path/subpath/42"
-)
-public String myAction(int id) { ... }
-```
-
-### Parameterized Paths
-```java
-@Action("user/{id}")
-public String getUser(int id) { ... }
-// → CLI: bin/dispatcher user/42
-// → HTTP: /?q=user/42
-```
-
-### Dependency Injection
-`ActionRegistry` automatically injects `Request` and/or `Response` from `Context` if they are parameters:
-
-```java
-@Action(value = "upload", mode = Mode.HTTP_POST)
-public String upload(Request<?, ?> req, Response<?, ?> res) throws ApplicationException {
-    // Access raw request/response if needed
-    return "ok";
-}
-```
-
-### Path Matching Priority
-If two methods share the same path, the framework uses the first match in the `ActionRegistry`. Use explicit `Mode` values to disambiguate (e.g., separating a GET for a form and a POST for submission).
+# tinystruct @Action Routing Reference
+
+## When to Use
+
+Use the `@Action` annotation in your applications to define routes for both CLI commands and HTTP endpoints. It is appropriate whenever you need to map logic to a specific path, handle parameterized requests, or restrict execution to specific HTTP methods while maintaining a consistent command structure across environments.
+
+## How It Works
+
+The `ActionRegistry` parses `@Action` annotations to build a routing table. For parameterized methods, the framework automatically maps Java parameter types to corresponding regex segments.
+
+### Regex Generation Rules
+- `getUser(int id)` → pattern: `^/?user/(-?\d+)$`
+- `search(String query)` → pattern: `^/?search/([^/]+)$`
+
+Supported parameter types: `String`, `int/Integer`, `long/Long`, `float/Float`, `double/Double`, `boolean/Boolean`, `char/Character`, `short/Short`, `byte/Byte`, `Date` (parsed as `yyyy-MM-dd HH:mm:ss`).
+
+### Mode Values
+
+| Mode | When it triggers |
+|---|---|
+| `DEFAULT` | Both CLI and HTTP (GET, POST, etc.) |
+| `CLI` | CLI dispatcher only |
+| `HTTP_GET` | HTTP GET only |
+| `HTTP_POST` | HTTP POST only |
+| `HTTP_PUT` | HTTP PUT only |
+| `HTTP_DELETE` | HTTP DELETE only |
+| `HTTP_PATCH` | HTTP PATCH only |
+
+> **Note:** You can map HTTP method names to `Mode` using `Action.Mode.fromName(String methodName)`. Unknown or null values return `Mode.DEFAULT`.
+
+## Examples
+
+### Basic Action Declaration
+```java
+@Action(
+    value = "path/subpath",          // required: URI segment or CLI command
+    description = "What it does",    // shown in --help output
+    mode = Mode.DEFAULT,             // default: Mode.DEFAULT
+    example = "bin/dispatcher path/subpath/42"
+)
+public String myAction(int id) { ... }
+```
+
+### Parameterized Paths
+```java
+@Action("user/{id}")
+public String getUser(int id) { ... }
+// → CLI: bin/dispatcher user/42
+// → HTTP: /?q=user/42
+```
+
+### Dependency Injection
+`ActionRegistry` automatically injects `Request` and/or `Response` from `Context` if they are parameters:
+
+```java
+@Action(value = "upload", mode = Mode.HTTP_POST)
+public String upload(Request<?, ?> req, Response<?, ?> res) throws ApplicationException {
+    // Access raw request/response if needed
+    return "ok";
+}
+```
+
+### Path Matching Priority
+If two methods share the same path, the framework uses the first match in the `ActionRegistry`. Use explicit `Mode` values to disambiguate (e.g., separating a GET for a form and a POST for submission).

package/seed/marketplaces/ecc/skills/tinystruct-patterns/references/system-usage.md

@@ -1,97 +1,97 @@
-# tinystruct System and Usage Reference
-
-## When to Use
-
-Use these patterns to handle request state, manage web sessions, implement Server-Sent Events (SSE), handle file uploads, or perform outbound HTTP networking.
-
-## How It Works
-
-### Context and CLI Arguments
-`Context` is the primary data store for request-specific state. CLI flags passed as `--key value` are stored in `Context` as `"--key"`.
-
-### Session Management
-Pluggable architecture. Default is `MemorySessionRepository`. Configure Redis in `application.properties`:
-```properties
-default.session.repository=org.tinystruct.http.RedisSessionRepository
-redis.host=127.0.0.1
-redis.port=6379
-```
-
-### Server-Sent Events (SSE)
-Built-in support for real-time push. The `HttpServer` automatically handles the SSE lifecycle when it detects the `Accept: text/event-stream` header. Connections are tracked by session ID in `SSEPushManager`.
-
-### Outbound Networking
-Use `URLRequest` and `HTTPHandler` for making HTTP requests to external services.
-
-## Examples
-
-### Context and CLI Arguments
-```java
-@Action("echo")
-public String echo() {
-    // CLI: bin/dispatcher echo --words "Hello World"
-    Object words = getContext().getAttribute("--words");
-    if (words != null) return words.toString();
-    return "No words provided";
-}
-```
-
-### Session Management
-```java
-@Action(value = "login", mode = Mode.HTTP_POST)
-public String login(Request<?, ?> request) {
-    request.getSession().setAttribute("userId", "42");
-    return "Logged in";
-}
-```
-
-### Server-Sent Events (SSE)
-```java
-@Action("sse/connect")
-public String connect() {
-    return "{\"type\":\"connect\",\"message\":\"Connected\"}";
-}
-
-// In another method or event handler:
-String sessionId = getContext().getId();
-SSEPushManager.getInstance().push(sessionId, new Builder().put("msg", "hello"));
-```
-
-### File Uploads
-```java
-import org.tinystruct.data.FileEntity;
-
-@Action(value = "upload", mode = Mode.HTTP_POST)
-public String upload(Request<?, ?> request) throws ApplicationException {
-    List<FileEntity> files = request.getAttachments();
-    if (files != null) {
-        for (FileEntity file : files) {
-            // file.getFilename(), file.getContent()
-        }
-    }
-    return "Uploaded";
-}
-```
-
-### Outbound HTTP
-```java
-import org.tinystruct.net.URLRequest;
-import org.tinystruct.net.handlers.HTTPHandler;
-
-URLRequest request = new URLRequest(new URL("https://api.example.com"));
-request.setMethod("POST").setBody("{\"data\":\"val\"}");
-
-HTTPHandler handler = new HTTPHandler();
-var response = handler.handleRequest(request);
-if (response.getStatusCode() == 200) {
-    String body = response.getBody();
-}
-```
-
-### Event System
-Register handlers in `init()` for asynchronous task execution.
-```java
-EventDispatcher.getInstance().registerHandler(MyEvent.class, event -> {
-    CompletableFuture.runAsync(() -> doHeavyWork(event.getPayload()));
-});
-```
+# tinystruct System and Usage Reference
+
+## When to Use
+
+Use these patterns to handle request state, manage web sessions, implement Server-Sent Events (SSE), handle file uploads, or perform outbound HTTP networking.
+
+## How It Works
+
+### Context and CLI Arguments
+`Context` is the primary data store for request-specific state. CLI flags passed as `--key value` are stored in `Context` as `"--key"`.
+
+### Session Management
+Pluggable architecture. Default is `MemorySessionRepository`. Configure Redis in `application.properties`:
+```properties
+default.session.repository=org.tinystruct.http.RedisSessionRepository
+redis.host=127.0.0.1
+redis.port=6379
+```
+
+### Server-Sent Events (SSE)
+Built-in support for real-time push. The `HttpServer` automatically handles the SSE lifecycle when it detects the `Accept: text/event-stream` header. Connections are tracked by session ID in `SSEPushManager`.
+
+### Outbound Networking
+Use `URLRequest` and `HTTPHandler` for making HTTP requests to external services.
+
+## Examples
+
+### Context and CLI Arguments
+```java
+@Action("echo")
+public String echo() {
+    // CLI: bin/dispatcher echo --words "Hello World"
+    Object words = getContext().getAttribute("--words");
+    if (words != null) return words.toString();
+    return "No words provided";
+}
+```
+
+### Session Management
+```java
+@Action(value = "login", mode = Mode.HTTP_POST)
+public String login(Request<?, ?> request) {
+    request.getSession().setAttribute("userId", "42");
+    return "Logged in";
+}
+```
+
+### Server-Sent Events (SSE)
+```java
+@Action("sse/connect")
+public String connect() {
+    return "{\"type\":\"connect\",\"message\":\"Connected\"}";
+}
+
+// In another method or event handler:
+String sessionId = getContext().getId();
+SSEPushManager.getInstance().push(sessionId, new Builder().put("msg", "hello"));
+```
+
+### File Uploads
+```java
+import org.tinystruct.data.FileEntity;
+
+@Action(value = "upload", mode = Mode.HTTP_POST)
+public String upload(Request<?, ?> request) throws ApplicationException {
+    List<FileEntity> files = request.getAttachments();
+    if (files != null) {
+        for (FileEntity file : files) {
+            // file.getFilename(), file.getContent()
+        }
+    }
+    return "Uploaded";
+}
+```
+
+### Outbound HTTP
+```java
+import org.tinystruct.net.URLRequest;
+import org.tinystruct.net.handlers.HTTPHandler;
+
+URLRequest request = new URLRequest(new URL("https://api.example.com"));
+request.setMethod("POST").setBody("{\"data\":\"val\"}");
+
+HTTPHandler handler = new HTTPHandler();
+var response = handler.handleRequest(request);
+if (response.getStatusCode() == 200) {
+    String body = response.getBody();
+}
+```
+
+### Event System
+Register handlers in `init()` for asynchronous task execution.
+```java
+EventDispatcher.getInstance().registerHandler(MyEvent.class, event -> {
+    CompletableFuture.runAsync(() -> doHeavyWork(event.getPayload()));
+});
+```