pretticlaw 0.1.0

package/src/skills/tmux/scripts/find-sessions.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'USAGE'
+Usage: find-sessions.sh [-L socket-name|-S socket-path|-A] [-q pattern]
+
+List tmux sessions on a socket (default tmux socket if none provided).
+
+Options:
+  -L, --socket       tmux socket name (passed to tmux -L)
+  -S, --socket-path  tmux socket path (passed to tmux -S)
+  -A, --all          scan all sockets under PRETTICLAW_TMUX_SOCKET_DIR
+  -q, --query        case-insensitive substring to filter session names
+  -h, --help         show this help
+USAGE
+}
+
+socket_name=""
+socket_path=""
+query=""
+scan_all=false
+socket_dir="${PRETTICLAW_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/pretticlaw-tmux-sockets}"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -L|--socket)      socket_name="${2-}"; shift 2 ;;
+    -S|--socket-path) socket_path="${2-}"; shift 2 ;;
+    -A|--all)         scan_all=true; shift ;;
+    -q|--query)       query="${2-}"; shift 2 ;;
+    -h|--help)        usage; exit 0 ;;
+    *) echo "Unknown option: $1" >&2; usage; exit 1 ;;
+  esac
+done
+
+if [[ "$scan_all" == true && ( -n "$socket_name" || -n "$socket_path" ) ]]; then
+  echo "Cannot combine --all with -L or -S" >&2
+  exit 1
+fi
+
+if [[ -n "$socket_name" && -n "$socket_path" ]]; then
+  echo "Use either -L or -S, not both" >&2
+  exit 1
+fi
+
+if ! command -v tmux >/dev/null 2>&1; then
+  echo "tmux not found in PATH" >&2
+  exit 1
+fi
+
+list_sessions() {
+  local label="$1"; shift
+  local tmux_cmd=(tmux "$@")
+
+  if ! sessions="$("${tmux_cmd[@]}" list-sessions -F '#{session_name}\t#{session_attached}\t#{session_created_string}' 2>/dev/null)"; then
+    echo "No tmux server found on $label" >&2
+    return 1
+  fi
+
+  if [[ -n "$query" ]]; then
+    sessions="$(printf '%s\n' "$sessions" | grep -i -- "$query" || true)"
+  fi
+
+  if [[ -z "$sessions" ]]; then
+    echo "No sessions found on $label"
+    return 0
+  fi
+
+  echo "Sessions on $label:"
+  printf '%s\n' "$sessions" | while IFS=$'\t' read -r name attached created; do
+    attached_label=$([[ "$attached" == "1" ]] && echo "attached" || echo "detached")
+    printf '  - %s (%s, started %s)\n' "$name" "$attached_label" "$created"
+  done
+}
+
+if [[ "$scan_all" == true ]]; then
+  if [[ ! -d "$socket_dir" ]]; then
+    echo "Socket directory not found: $socket_dir" >&2
+    exit 1
+  fi
+
+  shopt -s nullglob
+  sockets=("$socket_dir"/*)
+  shopt -u nullglob
+
+  if [[ "${#sockets[@]}" -eq 0 ]]; then
+    echo "No sockets found under $socket_dir" >&2
+    exit 1
+  fi
+
+  exit_code=0
+  for sock in "${sockets[@]}"; do
+    if [[ ! -S "$sock" ]]; then
+      continue
+    fi
+    list_sessions "socket path '$sock'" -S "$sock" || exit_code=$?
+  done
+  exit "$exit_code"
+fi
+
+tmux_cmd=(tmux)
+socket_label="default socket"
+
+if [[ -n "$socket_name" ]]; then
+  tmux_cmd+=(-L "$socket_name")
+  socket_label="socket name '$socket_name'"
+elif [[ -n "$socket_path" ]]; then
+  tmux_cmd+=(-S "$socket_path")
+  socket_label="socket path '$socket_path'"
+fi
+
+list_sessions "$socket_label" "${tmux_cmd[@]:1}"

package/src/skills/tmux/scripts/wait-for-text.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'USAGE'
+Usage: wait-for-text.sh -t target -p pattern [options]
+
+Poll a tmux pane for text and exit when found.
+
+Options:
+  -t, --target    tmux target (session:window.pane), required
+  -p, --pattern   regex pattern to look for, required
+  -F, --fixed     treat pattern as a fixed string (grep -F)
+  -T, --timeout   seconds to wait (integer, default: 15)
+  -i, --interval  poll interval in seconds (default: 0.5)
+  -l, --lines     number of history lines to inspect (integer, default: 1000)
+  -h, --help      show this help
+USAGE
+}
+
+target=""
+pattern=""
+grep_flag="-E"
+timeout=15
+interval=0.5
+lines=1000
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -t|--target)   target="${2-}"; shift 2 ;;
+    -p|--pattern)  pattern="${2-}"; shift 2 ;;
+    -F|--fixed)    grep_flag="-F"; shift ;;
+    -T|--timeout)  timeout="${2-}"; shift 2 ;;
+    -i|--interval) interval="${2-}"; shift 2 ;;
+    -l|--lines)    lines="${2-}"; shift 2 ;;
+    -h|--help)     usage; exit 0 ;;
+    *) echo "Unknown option: $1" >&2; usage; exit 1 ;;
+  esac
+done
+
+if [[ -z "$target" || -z "$pattern" ]]; then
+  echo "target and pattern are required" >&2
+  usage
+  exit 1
+fi
+
+if ! [[ "$timeout" =~ ^[0-9]+$ ]]; then
+  echo "timeout must be an integer number of seconds" >&2
+  exit 1
+fi
+
+if ! [[ "$lines" =~ ^[0-9]+$ ]]; then
+  echo "lines must be an integer" >&2
+  exit 1
+fi
+
+if ! command -v tmux >/dev/null 2>&1; then
+  echo "tmux not found in PATH" >&2
+  exit 1
+fi
+
+# End time in epoch seconds (integer, good enough for polling)
+start_epoch=$(date +%s)
+deadline=$((start_epoch + timeout))
+
+while true; do
+  # -J joins wrapped lines, -S uses negative index to read last N lines
+  pane_text="$(tmux capture-pane -p -J -t "$target" -S "-${lines}" 2>/dev/null || true)"
+
+  if printf '%s\n' "$pane_text" | grep $grep_flag -- "$pattern" >/dev/null 2>&1; then
+    exit 0
+  fi
+
+  now=$(date +%s)
+  if (( now >= deadline )); then
+    echo "Timed out after ${timeout}s waiting for pattern: $pattern" >&2
+    echo "Last ${lines} lines from $target:" >&2
+    printf '%s\n' "$pane_text" >&2
+    exit 1
+  fi
+
+  sleep "$interval"
+done

package/src/skills/weather/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: weather
+description: Get current weather and forecasts (no API key required).
+homepage: https://wttr.in/:help
+metadata: {"pretticlaw":{"emoji":"🌤️","requires":{"bins":["curl"]}}}
+---
+
+# Weather
+
+Two free services, no API keys needed.
+
+## wttr.in (primary)
+
+Quick one-liner:
+```bash
+curl -s "wttr.in/London?format=3"
+# Output: London: ⛅️ +8°C
+```
+
+Compact format:
+```bash
+curl -s "wttr.in/London?format=%l:+%c+%t+%h+%w"
+# Output: London: ⛅️ +8°C 71% ↙5km/h
+```
+
+Full forecast:
+```bash
+curl -s "wttr.in/London?T"
+```
+
+Format codes: `%c` condition · `%t` temp · `%h` humidity · `%w` wind · `%l` location · `%m` moon
+
+Tips:
+- URL-encode spaces: `wttr.in/New+York`
+- Airport codes: `wttr.in/JFK`
+- Units: `?m` (metric) `?u` (USCS)
+- Today only: `?1` · Current only: `?0`
+- PNG: `curl -s "wttr.in/Berlin.png" -o /tmp/weather.png`
+
+## Open-Meteo (fallback, JSON)
+
+Free, no key, good for programmatic use:
+```bash
+curl -s "https://api.open-meteo.com/v1/forecast?latitude=51.5&longitude=-0.12&current_weather=true"
+```
+
+Find coordinates for a city, then query. Returns JSON with temp, windspeed, weathercode.
+
+Docs: https://open-meteo.com/en/docs

package/src/templates/AGENTS.md

@@ -0,0 +1,23 @@
+# Agent Instructions
+
+You are a helpful AI assistant. Be concise, accurate, and friendly.
+
+## Scheduled Reminders
+
+When user asks for a reminder at a specific time, use `exec` to run:
+```
+pretticlaw cron add --name "reminder" --message "Your message" --at "YYYY-MM-DDTHH:MM:SS" --deliver --to "USER_ID" --channel "CHANNEL"
+```
+Get USER_ID and CHANNEL from the current session (e.g., `8281248569` and `telegram` from `telegram:8281248569`).
+
+**Do NOT just write reminders to MEMORY.md** — that won't trigger actual notifications.
+
+## Heartbeat Tasks
+
+`HEARTBEAT.md` is checked every 30 minutes. Use file tools to manage periodic tasks:
+
+- **Add**: `edit_file` to append new tasks
+- **Remove**: `edit_file` to delete completed tasks
+- **Rewrite**: `write_file` to replace all tasks
+
+When the user asks for a recurring/periodic task, update `HEARTBEAT.md` instead of creating a one-time cron reminder.

package/src/templates/HEARTBEAT.md

@@ -0,0 +1,16 @@
+# Heartbeat Tasks
+
+This file is checked every 30 minutes by your pretticlaw agent.
+Add tasks below that you want the agent to work on periodically.
+
+If this file has no tasks (only headers and comments), the agent will skip the heartbeat.
+
+## Active Tasks
+
+<!-- Add your periodic tasks below this line -->
+
+
+## Completed
+
+<!-- Move completed tasks here or delete them -->
+

package/src/templates/SOUL.md

@@ -0,0 +1,21 @@
+# Soul
+
+I am pretticlaw 💅, a personal AI assistant.
+
+## Personality
+
+- Helpful and friendly
+- Concise and to the point
+- Curious and eager to learn
+
+## Values
+
+- Accuracy over speed
+- User privacy and safety
+- Transparency in actions
+
+## Communication Style
+
+- Be clear and direct
+- Explain reasoning when helpful
+- Ask clarifying questions when needed

package/src/templates/TOOLS.md

@@ -0,0 +1,15 @@
+# Tool Usage Notes
+
+Tool signatures are provided automatically via function calling.
+This file documents non-obvious constraints and usage patterns.
+
+## exec — Safety Limits
+
+- Commands have a configurable timeout (default 60s)
+- Dangerous commands are blocked (rm -rf, format, dd, shutdown, etc.)
+- Output is truncated at 10,000 characters
+- `restrictToWorkspace` config can limit file access to the workspace
+
+## cron — Scheduled Reminders
+
+- Please refer to cron skill for usage.

package/src/templates/USER.md

@@ -0,0 +1,49 @@
+# User Profile
+
+Information about the user to help personalize interactions.
+
+## Basic Information
+
+- **Name**: (your name)
+- **Timezone**: (your timezone, e.g., UTC+8)
+- **Language**: (preferred language)
+
+## Preferences
+
+### Communication Style
+
+- [ ] Casual
+- [ ] Professional
+- [ ] Technical
+
+### Response Length
+
+- [ ] Brief and concise
+- [ ] Detailed explanations
+- [ ] Adaptive based on question
+
+### Technical Level
+
+- [ ] Beginner
+- [ ] Intermediate
+- [ ] Expert
+
+## Work Context
+
+- **Primary Role**: (your role, e.g., developer, researcher)
+- **Main Projects**: (what you're working on)
+- **Tools You Use**: (IDEs, languages, frameworks)
+
+## Topics of Interest
+
+- 
+- 
+- 
+
+## Special Instructions
+
+(Any specific instructions for how the assistant should behave)
+
+---
+
+*Edit this file to customize pretticlaw's behavior for your needs.*

package/src/templates/memory/MEMORY.md

@@ -0,0 +1,23 @@
+# Long-term Memory
+
+This file stores important information that should persist across sessions.
+
+## User Information
+
+(Important facts about the user)
+
+## Preferences
+
+(User preferences learned over time)
+
+## Project Context
+
+(Information about ongoing projects)
+
+## Important Notes
+
+(Things to remember)
+
+---
+
+*This file is automatically updated by pretticlaw when important information should be remembered.*

package/src/types/prompts.d.ts

@@ -0,0 +1,14 @@
+declare module "prompts" {
+  export type PromptChoice = { title: string; value: string };
+  export type PromptQuestion = {
+    type: "select" | "password" | "text" | "confirm";
+    name: string;
+    message: string;
+    choices?: PromptChoice[];
+    initial?: string | boolean;
+    validate?: (value: string) => true | string;
+  };
+
+  const prompts: (question: PromptQuestion) => Promise<Record<string, unknown>>;
+  export default prompts;
+}

package/src/types/ws.d.ts

@@ -0,0 +1,15 @@
+declare module "ws" {
+  export type RawData = string | Buffer | ArrayBuffer | Buffer[];
+
+  type Listener = (...args: any[]) => void;
+
+  export default class WebSocket {
+    static readonly OPEN: number;
+    readonly readyState: number;
+    constructor(url: string);
+    on(event: "message", listener: (data: RawData) => void): this;
+    on(event: "close" | "error" | string, listener: Listener): this;
+    send(data: string | Buffer): void;
+    close(): void;
+  }
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+export type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
+
+export function nowIso(): string {
+  return new Date().toISOString();
+}

package/src/utils/helpers.ts

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+
+const UNSAFE = /[<>:"/\\|?*]/g;
+
+export function ensureDir(dir: string): string {
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function getDataPath(): string {
+  return ensureDir(path.join(os.homedir(), ".pretticlaw"));
+}
+
+export function getWorkspacePath(workspace?: string): string {
+  const p = workspace ? workspace.replace(/^~(?=$|[\\/])/, os.homedir()) : path.join(os.homedir(), ".pretticlaw", "workspace");
+  return ensureDir(path.resolve(p));
+}
+
+export function safeFilename(name: string): string {
+  return name.replace(UNSAFE, "_").trim();
+}
+
+export function syncWorkspaceTemplates(workspace: string, silent = false): string[] {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, "../templates"),
+    path.resolve(here, "../../src/templates"),
+    path.resolve(process.cwd(), "dist/templates"),
+    path.resolve(process.cwd(), "src/templates"),
+  ];
+  const templates = candidates.find((p) => fs.existsSync(path.join(p, "AGENTS.md")));
+  if (!templates) return [];
+  const created: string[] = [];
+  const writeIfMissing = (src: string | null, dest: string) => {
+    if (fs.existsSync(dest)) return;
+    ensureDir(path.dirname(dest));
+    if (src) fs.copyFileSync(src, dest);
+    else fs.writeFileSync(dest, "", "utf8");
+    created.push(path.relative(workspace, dest));
+  };
+
+  const md = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "HEARTBEAT.md"];
+  for (const f of md) writeIfMissing(path.join(templates, f), path.join(workspace, f));
+  writeIfMissing(path.join(templates, "memory", "MEMORY.md"), path.join(workspace, "memory", "MEMORY.md"));
+  writeIfMissing(null, path.join(workspace, "memory", "HISTORY.md"));
+  ensureDir(path.join(workspace, "skills"));
+
+  if (!silent) {
+    for (const item of created) console.log(`  Created ${item}`);
+  }
+  return created;
+}

package/src/web/server.ts

@@ -0,0 +1,198 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import type { AgentLoop } from "../agent/loop.js";
+import type { CronService } from "../cron/service.js";
+import type { Config } from "../config/schema.js";
+import { loadConfig, saveConfig } from "../config/loader.js";
+import type { SessionManager } from "../session/manager.js";
+
+type JsonObj = Record<string, unknown>;
+
+function dashboardDir(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, "../dashboard"),
+    path.resolve(here, "../../src/dashboard"),
+    path.resolve(process.cwd(), "dist/dashboard"),
+    path.resolve(process.cwd(), "src/dashboard"),
+  ];
+  const found = candidates.find((p) => fs.existsSync(path.join(p, "index.html")));
+  return found ?? candidates[candidates.length - 1];
+}
+
+function readBody(req: IncomingMessage): Promise<JsonObj> {
+  return new Promise((resolve) => {
+    let buf = "";
+    req.on("data", (c) => {
+      buf += c.toString();
+      if (buf.length > 2_000_000) req.destroy();
+    });
+    req.on("end", () => {
+      try {
+        resolve(buf ? (JSON.parse(buf) as JsonObj) : {});
+      } catch {
+        resolve({});
+      }
+    });
+    req.on("error", () => resolve({}));
+  });
+}
+
+function sendJson(res: ServerResponse, status: number, data: unknown): void {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(data));
+}
+
+function contentType(file: string): string {
+  if (file.endsWith(".html")) return "text/html; charset=utf-8";
+  if (file.endsWith(".js")) return "text/javascript; charset=utf-8";
+  if (file.endsWith(".css")) return "text/css; charset=utf-8";
+  if (file.endsWith(".json")) return "application/json; charset=utf-8";
+  if (file.endsWith(".svg")) return "image/svg+xml";
+  return "application/octet-stream";
+}
+
+export function startDashboardServer(input: {
+  agent: AgentLoop;
+  cron: CronService;
+  config: Config;
+  sessionManager: SessionManager;
+  sessionKey: string;
+  port?: number;
+}): { close: () => Promise<void>; port: number } {
+  const staticDir = dashboardDir();
+
+  const server = createServer(async (req, res) => {
+    const method = req.method || "GET";
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const pathname = url.pathname;
+
+    if (method === "GET" && pathname === "/api/status") {
+      const cfg = loadConfig();
+      return sendJson(res, 200, {
+        provider: cfg.agents.defaults.provider,
+        model: cfg.agents.defaults.model,
+        cron: input.cron.status(),
+        channels: cfg.channels,
+        gateway: cfg.gateway,
+      });
+    }
+
+    if (method === "GET" && pathname === "/api/history") {
+      const session = input.sessionManager.getOrCreate(input.sessionKey);
+      // Attach tool_calls (full objects) if present
+      type MsgWithTools = typeof session.messages[number] & { tool_calls?: any[] };
+      const messages: MsgWithTools[] = (session.messages || []).map(msg => {
+        if (msg && Array.isArray((msg as any).tool_calls)) {
+          return { ...msg, tool_calls: (msg as any).tool_calls };
+        }
+        return msg as MsgWithTools;
+      });
+      return sendJson(res, 200, { messages });
+    }
+
+    if (method === "POST" && pathname === "/api/chat") {
+      const body = await readBody(req);
+      const message = String(body.message ?? "").trim();
+      const session = String(body.session ?? "web:dashboard");
+      if (!message) return sendJson(res, 400, { error: "message required" });
+      const progress: Array<{ content: string; toolHint: boolean; tool_calls?: any[] }> = [];
+      try {
+        const response = await input.agent.processDirect(
+          message,
+          session,
+          "cli",
+          "dashboard",
+          async (content, meta) => {
+            // meta.tool_calls may exist (array of tool call objects)
+            progress.push({ content, toolHint: !!meta?.toolHint, tool_calls: meta?.tool_calls });
+          },
+        );
+        return sendJson(res, 200, { response, progress });
+      } catch (err) {
+        return sendJson(res, 500, { error: String(err) });
+      }
+    }
+
+    if (method === "GET" && pathname === "/api/config") {
+      return sendJson(res, 200, loadConfig());
+    }
+
+    if (method === "PUT" && pathname === "/api/config") {
+      const raw = await readBody(req);
+      const cfg = raw as unknown as Config;
+      saveConfig(cfg);
+      return sendJson(res, 200, { ok: true });
+    }
+
+    if (method === "GET" && pathname === "/api/cron/jobs") {
+      const includeDisabled = url.searchParams.get("all") === "1";
+      return sendJson(res, 200, input.cron.listJobs(includeDisabled));
+    }
+
+    if (method === "POST" && pathname === "/api/cron/jobs") {
+      const body = await readBody(req);
+      try {
+        const job = input.cron.addJob({
+          name: String(body.name ?? "job"),
+          schedule: body.schedule as any,
+          message: String(body.message ?? ""),
+          deliver: !!body.deliver,
+          channel: body.channel ? String(body.channel) : undefined,
+          to: body.to ? String(body.to) : undefined,
+          deleteAfterRun: !!body.deleteAfterRun,
+        });
+        return sendJson(res, 200, job);
+      } catch (err) {
+        return sendJson(res, 400, { error: String(err) });
+      }
+    }
+
+    const cronIdMatch = pathname.match(/^\/api\/cron\/jobs\/([^/]+)$/);
+    if (cronIdMatch && method === "DELETE") {
+      return sendJson(res, 200, { ok: input.cron.removeJob(cronIdMatch[1]) });
+    }
+
+    const cronEnableMatch = pathname.match(/^\/api\/cron\/jobs\/([^/]+)\/enable$/);
+    if (cronEnableMatch && method === "POST") {
+      const body = await readBody(req);
+      const enabled = body.enabled !== false;
+      const job = input.cron.enableJob(cronEnableMatch[1], enabled);
+      if (!job) return sendJson(res, 404, { error: "not found" });
+      return sendJson(res, 200, job);
+    }
+
+    const cronRunMatch = pathname.match(/^\/api\/cron\/jobs\/([^/]+)\/run$/);
+    if (cronRunMatch && method === "POST") {
+      const body = await readBody(req);
+      const ok = await input.cron.runJob(cronRunMatch[1], !!body.force);
+      return sendJson(res, 200, { ok });
+    }
+
+    let filePath = path.join(staticDir, pathname === "/" ? "index.html" : pathname.slice(1));
+    if (!filePath.startsWith(staticDir)) filePath = path.join(staticDir, "index.html");
+    if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+      filePath = path.join(staticDir, "index.html");
+    }
+    if (!fs.existsSync(filePath)) {
+      res.statusCode = 404;
+      res.end("Dashboard assets not found. Run npm run build.");
+      return;
+    }
+
+    res.statusCode = 200;
+    res.setHeader("Content-Type", contentType(filePath));
+    fs.createReadStream(filePath).pipe(res);
+  });
+
+  const port = input.port ?? 6767;
+  server.listen(port);
+
+  return {
+    port,
+    close: () => new Promise<void>((resolve, reject) => server.close((err) => (err ? reject(err) : resolve()))),
+  };
+}