lampson 0.2.7 → 0.2.8

package/README.md

@@ -95,7 +95,8 @@ plugins were called *lamps*; old `.lampson/lamps/` folders and `LAMP_*` variable
 
 Sub-agents that work in parallel · skills (`SKILL.md` procedures, anything on [skills.sh](https://skills.sh)
 works) · MCP servers with the JSON you already have · language servers for real go-to-definition · project
-memory it reads back next session · sessions with a readable trace of every step · paste a screenshot and ask.
+memory it reads back next session · sessions with a readable trace of every step · web pages fetched as
+Markdown (a tenth of the tokens of raw HTML) · paste a screenshot and ask.
 
 ## Learn more
 

package/chat.syn

@@ -165,7 +165,7 @@ task print_diff_with(lead, path, d)
 
 -- tools "instantáneas": la llamada se imprime junto con su resultado, en una sola línea
 task is_instant(name)
-    give name == "read" or name == "ls" or name == "find" or name == "grep" or name == "memory" or name == "edit" or name == "write" or name == "todo" or name == "lsp"
+    give name == "read" or name == "ls" or name == "find" or name == "grep" or name == "memory" or name == "edit" or name == "write" or name == "todo" or name == "lsp" or name == "fetch"
 
 let pending_call be ""
 

package/lib/agents.syn

@@ -40,27 +40,27 @@ let PARALLEL be 4
 
 export let PROFILES be {
     "build": {
-        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill", "mcp", "plugin", "schedule", "delegate"],
+        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "todo", "skill", "mcp", "plugin", "schedule", "delegate"],
         "steps": 40,
         "addendum": "You are in BUILD mode: you may read, edit, create files and run commands. Delegate exploration of large codebases to the `explore` agent and independent code review to the `review` agent when it saves context; several independent questions can go in one delegate call (they run in parallel)."
     },
     "plan": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "memory", "todo", "skill", "delegate"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "memory", "todo", "skill", "delegate"],
         "steps": 30,
         "addendum": "You are in PLAN mode: READ-ONLY. You cannot edit files or run commands (those tools are not available). Investigate the codebase, then answer with a concrete, numbered implementation plan: files to touch, what changes in each, risks, and how to verify. Do not write code beyond short illustrative snippets."
     },
     "review": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "bash", "process", "memory", "skill"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "skill"],
         "steps": 25,
         "addendum": "You are a REVIEWER: read-only on files (no write/edit), but you may run commands (tests, linters, git diff). Find real bugs, missing error handling, security issues and violations of the project's conventions. Report findings as a list with file:line, severity and a suggested fix. Do not modify files."
     },
     "explore": {
-        "tools": ["read", "ls", "find", "grep", "lsp", "memory", "skill"],
+        "tools": ["read", "ls", "find", "grep", "lsp", "fetch", "memory", "skill"],
         "steps": 20,
         "addendum": "You are an EXPLORER: read-only. Locate the code relevant to the question (files, functions, line numbers) and report it concisely with paths and short excerpts. Do not propose changes."
     },
     "worker": {
-        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "bash", "process", "memory", "todo", "skill"],
+        "tools": ["read", "write", "edit", "ls", "find", "grep", "lsp", "fetch", "bash", "process", "memory", "todo", "skill"],
         "steps": 40,
         "addendum": "You are a WORKER sub-agent: implement exactly the scoped task you were given (read, edit, run tests), then report what you changed (files) and how you verified it. Stay inside the scope; if something outside it is needed, report it instead of doing it."
     }

package/lib/fs.syn

@@ -0,0 +1,226 @@
+-- lib/fs.syn — operaciones de archivos del explorador web: crear, renombrar, mover, copiar, borrar
+--
+-- El runtime tiene write_file/list_dir/file_info pero NO rename/delete/copy/mkdir (v0.6.14), así que mover,
+-- copiar y borrar corren por el shell POSIX (Git Bash en Windows), igual que plugins.remove. Todo path viene
+-- del navegador y pasa por common.ws(): relativo al workspace, sin `..` ni absolutos (raise instructivo).
+-- Reglas al estilo VS Code: nunca pisar un destino existente; duplicar = "<nombre> copy<.ext>", luego
+-- "<nombre> copy 2<.ext>"…; una carpeta no se mueve/copia dentro de sí misma; la raíz no se toca.
+use "./tools/common.syn" as c
+
+task sh_quote(s)
+    give "'" + replace_text(s, "'", "'\\''") + "'"
+
+-- shell POSIX aunque LAMPSON_SHELL apunte a cmd: mv/cp/rm/mkdir son de Git Bash
+task shell()
+    require env("LAMPSON_*")
+    require env("OS")
+    let is_win be env("OS", "") == "Windows_NT"
+    let sh be env("LAMPSON_SHELL", when is_win then "C:\\Program Files\\Git\\bin\\bash.exe" otherwise "bash")
+    when is_win and not c.ends_with(lower(sh), "bash.exe")
+        set sh to "C:\\Program Files\\Git\\bin\\bash.exe"
+    give sh
+
+-- corre un comando con cwd = workspace; error legible si falla
+task sh(cmd)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    let r be run(shell(), ["-c", cmd], 30, {"cwd": c.ROOT})
+    when r["exit_code"] != 0
+        let err be trim(text(r["stderr"]))
+        raise(when err == "" then "command failed: " + cmd otherwise err)
+    give true
+
+-- path del navegador → {rel (como lo ve el modelo, "." = raíz), real ("workspace/…"), info}
+task target(path)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let real be c.ws(path)
+    give {"rel": c.unws(real), "real": real, "info": file_info(real)}
+
+task parent_of(rel)
+    when not contains(rel, "/")
+        give "."
+    let parts be split(rel, "/")
+    give join(slice(parts, 0, length(parts) - 1), "/")
+
+task base_of(rel)
+    let parts be split(rel, "/")
+    give parts[length(parts) - 1]
+
+task join_rel(dir, name)
+    give when dir == "." or dir == "" then name otherwise dir + "/" + name
+
+task check_name(name)
+    let n be trim(text(name))
+    when n == "" or n == "." or n == ".." or contains(n, "/") or contains(n, "\\")
+        raise("invalid name \"" + text(name) + "\": one path segment, without / or \\")
+    when length(find_all(n, "[<>:\"|?*]")) > 0
+        raise("invalid name \"" + n + "\": < > : \" | ? * are not allowed in file names")
+    give n
+
+task must_exist(t)
+    when not t["info"]["exists"]
+        raise("\"" + t["rel"] + "\" does not exist")
+
+task must_not_exist(rel)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    when file_exists(c.ROOT + "/" + rel)
+        raise("\"" + rel + "\" already exists")
+
+-- ¿`path` es `dir` o está dentro de `dir`?
+task inside(dir, path)
+    when dir == "."
+        give true
+    give path == dir or starts_with(path, dir + "/")
+
+task must_be_dir(rel, info)
+    when not info["exists"]
+        raise("\"" + rel + "\" does not exist")
+    when not info["is_dir"]
+        raise("\"" + rel + "\" is not a folder")
+
+export task mkdir(dir, name)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(dir)
+    let rel be join_rel(t["rel"], check_name(name))
+    must_not_exist(rel)
+    sh("mkdir -p " + sh_quote(rel))
+    give {"path": rel, "is_dir": true}
+
+export task create(dir, name, content)
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(dir)
+    let rel be join_rel(t["rel"], check_name(name))
+    must_not_exist(rel)
+    write_file(c.ROOT + "/" + rel, when content == nothing then "" otherwise text(content))
+    give {"path": rel, "is_dir": false}
+
+export task rename(path, name)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be renamed")
+    let rel be join_rel(parent_of(t["rel"]), check_name(name))
+    when rel == t["rel"]
+        give {"path": rel, "is_dir": t["info"]["is_dir"]}
+    -- solo cambian mayúsculas: en un FS case-insensitive el destino "existe" → pasar por un temporal
+    when lower(rel) == lower(t["rel"])
+        let tmp be rel + ".lampson-rename-tmp"
+        sh("mv " + sh_quote(t["rel"]) + " " + sh_quote(tmp) + " && mv " + sh_quote(tmp) + " " + sh_quote(rel))
+        give {"path": rel, "is_dir": t["info"]["is_dir"]}
+    must_not_exist(rel)
+    sh("mv " + sh_quote(t["rel"]) + " " + sh_quote(rel))
+    give {"path": rel, "is_dir": t["info"]["is_dir"]}
+
+export task move(path, to_dir)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be moved")
+    let d be target(to_dir)
+    must_be_dir(d["rel"], d["info"])
+    when t["info"]["is_dir"] and inside(t["rel"], d["rel"])
+        raise("cannot move a folder into itself")
+    let rel be join_rel(d["rel"], base_of(t["rel"]))
+    when rel == t["rel"]
+        give {"path": rel, "is_dir": t["info"]["is_dir"]}
+    must_not_exist(rel)
+    sh("mv " + sh_quote(t["rel"]) + " " + sh_quote(rel))
+    give {"path": rel, "is_dir": t["info"]["is_dir"]}
+
+-- "b.ts" en `dir` → "b copy.ts", "b copy 2.ts"…; carpetas y dotfiles: "sub copy", ".env copy"
+task copy_name(dir, base)
+    require file.read("workspace")
+    require file.read("workspace/*")
+    let stem be base
+    let ext be ""
+    let parts be split(base, ".")
+    when length(parts) > 1 and parts[0] != ""
+        set ext to "." + parts[length(parts) - 1]
+        set stem to slice(base, 0, length(base) - length(ext))
+    let n be 1
+    let cand be stem + " copy" + ext
+    while file_exists(c.ROOT + "/" + join_rel(dir, cand)) and n < 100
+        set n to n + 1
+        set cand to stem + " copy " + text(n) + ext
+    give cand
+
+-- to_dir = nothing → duplicar al lado; otra carpeta → copiar ahí (mismo nombre, o "copy" si ya hay uno)
+export task copy(path, to_dir)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be copied")
+    let dir be when to_dir == nothing then parent_of(t["rel"]) otherwise target(to_dir)["rel"]
+    must_be_dir(dir, file_info(c.ws(dir)))
+    when t["info"]["is_dir"] and inside(t["rel"], dir)
+        raise("cannot copy a folder into itself")
+    let base be base_of(t["rel"])
+    let rel be join_rel(dir, base)
+    when rel == t["rel"] or file_exists(c.ROOT + "/" + rel)
+        set rel to join_rel(dir, copy_name(dir, base))
+    sh("cp -r " + sh_quote(t["rel"]) + " " + sh_quote(rel))
+    give {"path": rel, "is_dir": t["info"]["is_dir"]}
+
+export task remove(path)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let t be target(path)
+    must_exist(t)
+    when t["rel"] == "."
+        raise("the workspace root cannot be deleted")
+    when t["rel"] == ".git" or t["rel"] == ".lampson"
+        raise("\"" + t["rel"] + "\" is not deleted from the explorer")
+    sh("rm -rf " + sh_quote(t["rel"]))
+    give {"path": t["rel"], "is_dir": t["info"]["is_dir"]}
+
+-- POST /api/fs: {op, path, name?, to?, content?} → {path, is_dir}
+export task apply(b)
+    require exec
+    require env("LAMPSON_*")
+    require env("OS")
+    require file("workspace")
+    require file("workspace/*")
+    let op be when contains(b, "op") then lower(text(b["op"])) otherwise ""
+    let path be when contains(b, "path") then text(b["path"]) otherwise "."
+    let name be when contains(b, "name") then b["name"] otherwise nothing
+    -- (`to` es palabra reservada: `set x to`)
+    let dest be when contains(b, "to") then text(b["to"]) otherwise nothing
+    when op == "mkdir"
+        give mkdir(path, name)
+    when op == "create"
+        give create(path, name, when contains(b, "content") then b["content"] otherwise "")
+    when op == "rename"
+        give rename(path, name)
+    when op == "move"
+        give move(path, when dest == nothing then "." otherwise dest)
+    when op == "copy"
+        give copy(path, dest)
+    when op == "delete"
+        give remove(path)
+    raise("unknown op '" + op + "' (mkdir, create, rename, move, copy, delete)")

package/lib/loop.syn

@@ -47,7 +47,7 @@ let REPEAT_HARD be 8
 -- seguidas sin ninguna acción (edit/write/bash/process/delegate/mcp). Visto 2026-08-28 con deepseek-v4-pro:
 -- 39 read/ls/find seguidos, 0 ediciones, 419k tokens, dos veces, con las reglas de prompt ignoradas.
 -- A la mitad del tope el resultado lleva un aviso; al tope, read/ls/find/grep se rechazan hasta que actúe.
-let READ_ONLY_TOOLS be ["read", "ls", "find", "grep"]
+let READ_ONLY_TOOLS be ["read", "ls", "find", "grep", "fetch"]
 let ACTION_TOOLS be ["edit", "write", "bash", "process", "delegate"]
 
 export task explore_cap()
@@ -67,7 +67,7 @@ export task explore_verdict(streak, name, cap)
     when n >= cap
         give {"streak": n, "note": "", "refuse": true}
     when n == floor(cap / 2)
-        give {"streak": n, "note": "\n\n[harness] " + text(n) + " read-only calls in a row without changing anything. You likely know enough: edit/write now, or run the relevant command. After " + text(cap) + " read-only calls in a row, read/ls/find/grep are refused until you act. If the codebase is genuinely too big, delegate ONE focused question to an `explore` sub-agent instead of reading everything yourself.", "refuse": false}
+        give {"streak": n, "note": "\n\n[harness] " + text(n) + " read-only calls in a row without changing anything. You likely know enough: edit/write now, or run the relevant command. After " + text(cap) + " read-only calls in a row, read/ls/find/grep/fetch are refused until you act. If the codebase is genuinely too big, delegate ONE focused question to an `explore` sub-agent instead of reading everything yourself.", "refuse": false}
     give {"streak": n, "note": "", "refuse": false}
 
 -- JSON canónico (claves ordenadas en profundidad): reordenar propiedades no engaña al detector
@@ -98,7 +98,8 @@ task safe_id(id, step)
 export task spill(name, id, out)
     require file(".lampson")
     require file(".lampson/*")
-    when name == "read" or length(out) <= SPILL_CAP
+    -- read y fetch se recortan solas (fetch: cabeza+cola con el texto completo ya en .lampson/spill)
+    when name == "read" or name == "fetch" or length(out) <= SPILL_CAP
         give out
     -- el informe de los subagentes es el entregable: no se manda a disco (hasta 60k)
     when name == "delegate" and length(out) <= SPILL_CAP * 6
@@ -394,7 +395,7 @@ export task run_turn(cfg, messages, opts, on_event)
                 set out to "ERROR: you already called " + tc["name"] + " with these exact arguments " + text(repeats) + " times in a row. The result will not change; try a different approach or report the problem."
                 emit(on_event, "tool_denied", {"call": tc, "reason": "repeated call (" + text(repeats) + "x)"}, tag)
             otherwise when ex["refuse"]
-                set out to "ERROR: exploration cap reached — " + text(explore_streak) + " read-only calls in a row (read/ls/find/grep) without a single change. Reading more will not help. Do one of: (1) edit/write the files you already read; (2) run a command (bash/process) that moves the task; (3) delegate ONE focused question to an `explore` sub-agent; (4) tell the user what you need. read/ls/find/grep are refused until you do."
+                set out to "ERROR: exploration cap reached — " + text(explore_streak) + " read-only calls in a row (read/ls/find/grep) without a single change. Reading more will not help. Do one of: (1) edit/write the files you already read; (2) run a command (bash/process) that moves the task; (3) delegate ONE focused question to an `explore` sub-agent; (4) tell the user what you need. read/ls/find/grep/fetch are refused until you do."
                 emit(on_event, "tool_denied", {"call": tc, "reason": "exploration cap (" + text(explore_streak) + " read-only calls without acting)"}, tag)
             otherwise when contains(READ_ONLY_TOOLS, tc["name"]) and reads_total >= turn_cap
                 set out to "ERROR: this turn already made " + text(reads_total) + " read-only calls (limit " + text(turn_cap) + "). Everything you read is in your context. Act on it now (edit/write/run), delegate ONE focused question to an `explore` sub-agent, or report to the user."

package/lib/permission.syn

@@ -9,6 +9,8 @@
 --
 -- Modos (LAMPSON_PERMISSION): "ask" (default) | "yolo" (dangerous → allow) | "strict" (dangerous → deny)
 
+use "./tools/url.syn" as u
+
 -- Tier 1: nunca. Coincidencia por substring, case-insensitive.
 -- (el comando se evalúa con un espacio final añadido, así "rm -rf / " matchea la raíz pero NO "rm -rf /tmp/x")
 export let HARDLINE be [
@@ -69,6 +71,27 @@ export task evaluate(name, args, mode)
                 give {"decision": "deny", "reason": "strict mode (dangerous: " + danger + ")"}
             give {"decision": "ask", "reason": "dangerous pattern: " + danger}
         give {"decision": "allow", "reason": "command"}
+    when name == "fetch"
+        -- política de hosts de url.syn (hermes url_safety): secretos en la URL y metadata de la nube se
+        -- deniegan SIEMPRE (incluso en yolo); hosts privados/loopback (el dev server del usuario) piden;
+        -- lo público se permite. Una URL inválida se permite: la tool devuelve el error explicado.
+        let furl be when contains(args, "url") then text(args["url"]) otherwise ""
+        let why be u.sensitive(furl)
+        when why != nothing
+            give {"decision": "deny", "reason": "the URL carries " + why + " — secrets never travel in URLs"}
+        let fp be u.parse(furl)
+        when not fp["ok"]
+            give {"decision": "allow", "reason": "invalid URL (the tool explains)"}
+        let cls be u.host_class(fp["host"])
+        when cls == "blocked"
+            give {"decision": "deny", "reason": "cloud metadata endpoint " + fp["host"]}
+        when cls == "private"
+            when mode == "yolo"
+                give {"decision": "allow", "reason": "yolo mode (private host " + fp["host"] + ")"}
+            when mode == "strict"
+                give {"decision": "deny", "reason": "strict mode (private host " + fp["host"] + ")"}
+            give {"decision": "ask", "reason": "fetches a private/loopback host (" + fp["origin"] + ")"}
+        give {"decision": "allow", "reason": "public URL"}
     when name == "write" or name == "edit"
         -- el scope file("./*") ya impide salir del workspace; aquí solo miramos secretos obvios
         let p be when contains(args, "path") then lower(replace_text(text(args["path"]), "\\", "/")) otherwise ""
@@ -167,6 +190,9 @@ export task describe_call(name, args)
         give "skill install " + text(args["source"]) + " --skill " + text(args["name"]) + " (" + (when contains(args, "scope") then text(args["scope"]) otherwise "global") + ")"
     when name == "bash"
         give "$ " + one_line(when contains(args, "command") then text(args["command"]) otherwise "", 160)
+    when name == "fetch"
+        let ffmt be arg(args, "format", "markdown")
+        give "fetch " + one_line(arg(args, "url", "?"), 140) + (when ffmt != "markdown" then " (" + ffmt + ")" otherwise "")
     -- lectura/búsqueda: como lo escribiría un humano en la shell
     when name == "read"
         let rng be when contains(args, "offset") or contains(args, "limit") then "  (" + (when contains(args, "offset") then "desde " + text(floor(number(text(args["offset"])))) otherwise "") + (when contains(args, "limit") then " " + text(floor(number(text(args["limit"])))) + " líneas" otherwise "") + ")" otherwise ""

package/lib/prompt.syn

@@ -53,6 +53,7 @@ Operate like a careful senior engineer: precise, honest, and economical with wor
 
 # Tools
 - read (offset/limit), ls, find (glob), grep (regex): use them instead of bash with cat/ls/find/grep — line-numbered and cheaper. lsp (symbols/definition/references/hover): the file's structure without reading it, and exact navigation when grep is ambiguous — prefer lsp symbols plus a ranged read over reading a big file whole. edit: targeted replacement. write: create or fully replace.
+- fetch (url, format, max_chars): web pages and HTTP APIs as Markdown — docs, READMEs, issues, changelogs, JSON. Use it instead of bash with curl/wget for anything you will read: it asks the site for Markdown first and strips scripts, styles and navigation, so a page costs a tenth of its HTML. A long page comes back head+tail with the full text saved to a file: read (offset/limit) or grep that file, never fetch the same URL again. Cite the URL when you use its content. Use bash+curl only for POST, custom headers or downloads.
 - bash: shell commands from the workspace root. State does not persist between calls (cd resets) — chain with &&. Check the [exit code: N] marker on every result (it is the last line) and investigate failures before moving on. Never pipe a build or test through head/tail: the output is already truncated for you (the full text is saved to a file whose path you get) and the pipe hides the real exit code. Never run a server or watcher here.
 - process: start/logs/stop long-running commands (dev servers, watchers). Their new log lines arrive automatically with every later tool result — do not sleep or poll. Stop what you started when the task is done.
 - delegate: sub-agents with a fresh context (explore, plan, review, worker); several tasks in one call run in parallel, background=true returns at once and the report arrives later as a message. Give a highly detailed, self-contained brief, say whether it should write code or only research, how to verify, and exactly what to return. Its report is a self-report — verify what matters before telling the user it is done. Its output is not visible to the user: summarise it.