Initial commit: omp-edit DSH plugin (oh-my-pi port) with docs and tests
This commit is contained in:
Agent committed
commit
71953ffb8f
19 files changed
+2412
No files matched your search
@@ -0,0 +1,611 @@
|
||||
/**
|
||||
* @local/omp-edit — oh-my-pi style editing for DSH.
|
||||
*
|
||||
* Replaces DSH's built-in `edit` (and wraps `read` / `grep`) in every agent scope:
|
||||
* - hashline (default): `[PATH#TAG]` + `PUT/CUT/REM/MV` patches anchored on line numbers of a
|
||||
* content-hashed snapshot, block (`N*`) anchors, cut/paste registers, multi-file, stale-tag
|
||||
* recovery;
|
||||
* - replace: fuzzy-whitespace string replacement with batched `edits`;
|
||||
* - sloppy: `*** Find / *** Replace / *** Insert Before|After` anchored patches;
|
||||
* - apply_patch: Codex-style `*** Begin Patch` add/update/delete/move.
|
||||
*
|
||||
* Mode resolution (per agent, per call): model-specific `modelVariants` → `mode` → hashline,
|
||||
* with oh-my-pi's fallback of weak-at-hashline model families to `replace` unless `strict`.
|
||||
*
|
||||
* Shadowing: DSH tools layers are per agent scope and a scoped registration shadows a
|
||||
* global/preset one, so every agent gets this plugin's `edit`/`read`/`grep` registered into its
|
||||
* own scope on `agent/created`. The built-in definitions keep working underneath (read/grep
|
||||
* delegate to them; edit is replaced outright).
|
||||
*/
|
||||
import path from 'node:path'
|
||||
import { SnapshotStore, rebaseOps } from './lib/store.js'
|
||||
import { parseHashline, applySection } from './lib/hashline.js'
|
||||
import { applyReplace } from './lib/replace.js'
|
||||
import { parseSloppy, applySloppy } from './lib/sloppy.js'
|
||||
import { parseApplyPatch, applyUpdate } from './lib/apply_patch.js'
|
||||
import { hunkDiffs } from './lib/diff.js'
|
||||
import {
|
||||
EditError, detectEol, fileTag, formatHeader, joinLines, numbered, preview, restoreEol, splitLines, toLF,
|
||||
} from './lib/text.js'
|
||||
import * as P from './lib/prompts.js'
|
||||
|
||||
export const name = 'omp-edit'
|
||||
export const inject = ['tools', 'fs', 'agents']
|
||||
|
||||
const MODES = ['hashline', 'replace', 'sloppy', 'apply_patch']
|
||||
// oh-my-pi falls these families back from hashline to replace unless strict mode is on.
|
||||
const DEFAULT_WEAK = ['kimi', 'mimo', 'minimax', 'deepseek', 'stepfun', 'codex-spark', 'glm-5.3-flash']
|
||||
|
||||
const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
|
||||
|
||||
export function resolveMode(config, model) {
|
||||
const m = String(model || '').toLowerCase()
|
||||
for (const [needle, mode] of Object.entries(config.modelVariants || {})) {
|
||||
if (needle && m.includes(needle.toLowerCase()) && MODES.includes(mode)) return mode
|
||||
}
|
||||
const base = MODES.includes(config.mode) ? config.mode : 'hashline'
|
||||
if (base === 'hashline' && !config.strict) {
|
||||
const weak = Array.isArray(config.fallbackModels) ? config.fallbackModels : DEFAULT_WEAK
|
||||
if (weak.some((w) => w && m.includes(String(w).toLowerCase()))) return config.fallbackMode || 'replace'
|
||||
}
|
||||
return base
|
||||
}
|
||||
|
||||
export function apply(ctx, config = {}) {
|
||||
const cfg = {
|
||||
mode: 'hashline',
|
||||
strict: false,
|
||||
fallbackMode: 'replace',
|
||||
fallbackModels: DEFAULT_WEAK,
|
||||
modelVariants: {},
|
||||
replaceRead: true,
|
||||
replaceGrep: true,
|
||||
replaceEdit: true,
|
||||
fuzzy: true,
|
||||
...config,
|
||||
}
|
||||
|
||||
/** @type {WeakMap<object, SnapshotStore>} per session */
|
||||
const stores = new WeakMap()
|
||||
const storeFor = (exec) => {
|
||||
const owner = exec?.agent?.session ?? ctx
|
||||
let s = stores.get(owner)
|
||||
if (!s) { s = new SnapshotStore(); stores.set(owner, s) }
|
||||
return s
|
||||
}
|
||||
/** Latest provider/model seen per agent (from agent/request). */
|
||||
const models = new WeakMap()
|
||||
const modeFor = (agent) => resolveMode(cfg, agent ? (models.get(agent) ?? agent.options?.model ?? '') : '')
|
||||
|
||||
const cwdOf = (exec) => exec?.agent?.session?.header?.cwd
|
||||
const resolveTarget = (p, exec) => ctx.fs.resolve(String(p).replace(/^\[(.+?)#[0-9A-Fa-f]{4}\]$/, '$1'), { ...(cwdOf(exec) ? { cwd: cwdOf(exec) } : {}), signal: exec?.signal })
|
||||
const relPath = (target, exec) => {
|
||||
const cwd = cwdOf(exec)
|
||||
const p = target.displayPath
|
||||
if (cwd && path.isAbsolute(p)) { const r = path.relative(cwd, p); if (r && !r.startsWith('..') && !path.isAbsolute(r)) return r }
|
||||
return p
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- fs helpers (respect DSH policy)
|
||||
|
||||
const sandboxPolicyFor = (exec) => {
|
||||
try { return ctx.get('sandboxPolicy')?.resolve({ ...(exec?.agent ? { session: exec.agent.session } : {}) }) } catch { return undefined }
|
||||
}
|
||||
|
||||
async function readFile(target, exec) {
|
||||
const info = await ctx.fs.stat(target, exec?.signal)
|
||||
if (!info) throw new EditError(`${target.displayPath}: not found. Use \`write\` to create new files.`)
|
||||
if (info.type !== 'file') throw new EditError(`${target.displayPath}: not a regular file.`)
|
||||
const raw = await ctx.fs.readText(target, exec?.signal)
|
||||
return { raw, text: toLF(raw), version: info.version }
|
||||
}
|
||||
|
||||
/**
|
||||
* DSH's edit gate (fs-observation-policy): the file must have been read in this session.
|
||||
* `checkVersion` additionally keeps DSH's "changed since it was read" rule (replace/sloppy/
|
||||
* apply_patch); hashline uses its snapshot tag instead, which also allows recovery.
|
||||
* Afterwards the current version is reported as observed so the guarded write below
|
||||
* targets exactly the text this call read.
|
||||
*/
|
||||
async function editGate(target, exec, cur, { checkVersion }) {
|
||||
const intent = await ctx.waterfall('fs/edit-intent', target, exec, () => undefined)
|
||||
if (checkVersion && intent?.version !== undefined && intent.version !== cur.version) {
|
||||
throw new EditError(`cannot edit "${target.displayPath}": file changed since it was read — re-read the file, then retry`)
|
||||
}
|
||||
ctx.emit('fs/observed', target, { kind: 'present', version: cur.version }, exec)
|
||||
}
|
||||
|
||||
/** Guarded write through ctx.fs (stale-safe against our own read), then report the observation. */
|
||||
async function writeFile(target, content, exec, { create = false, unconditional = false } = {}) {
|
||||
const intent = unconditional ? undefined : create ? { kind: 'createIfAbsent' } : await ctx.waterfall('fs/write-intent', target, exec, () => undefined)
|
||||
const outcome = await ctx.fs.writeText(target, content, intent, exec?.signal, sandboxPolicyFor(exec))
|
||||
ctx.emit('fs/observed', target, { kind: 'present', version: outcome.version }, exec)
|
||||
return outcome
|
||||
}
|
||||
|
||||
async function deleteFile(target, exec) {
|
||||
const p = ctx.fs.processPath(target)
|
||||
const policy = sandboxPolicyFor(exec)
|
||||
if (policy?.mode === 'read-only') throw new EditError(`[sandbox: deleting ${target.displayPath} is denied in read-only mode]`)
|
||||
if (policy?.mode === 'workspace-write' && policy.workspaceRoot) {
|
||||
const r = path.relative(policy.workspaceRoot, p)
|
||||
if (r.startsWith('..') || path.isAbsolute(r)) throw new EditError(`[sandbox: deleting ${target.displayPath} is outside the workspace]`)
|
||||
}
|
||||
const fsp = await import('node:fs/promises')
|
||||
await fsp.unlink(p)
|
||||
ctx.emit('fs/observed', target, { kind: 'absent' }, exec)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- shared mutation planner
|
||||
//
|
||||
// Every mode produces a plan: [{target, rel, before, after, op: 'update'|'create'|'delete'|'move', dest?}]
|
||||
// validated completely before anything is written; then committed in order.
|
||||
|
||||
async function commit(plan, exec) {
|
||||
const results = []
|
||||
for (const step of plan) {
|
||||
if (step.op === 'delete') { await deleteFile(step.target, exec); results.push({ path: step.rel, operation: 'delete' }); continue }
|
||||
const eol = step.eol ?? '\n'
|
||||
const content = restoreEol(step.after, eol)
|
||||
if (step.op === 'move') {
|
||||
await writeFile(step.destTarget, content, exec, { unconditional: true })
|
||||
await deleteFile(step.target, exec)
|
||||
results.push({ path: step.rel, movedTo: step.destRel, operation: 'move' })
|
||||
continue
|
||||
}
|
||||
await writeFile(step.target, content, exec, { create: step.op === 'create' })
|
||||
results.push({ path: step.rel, operation: step.op })
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
/** After a successful write: record the new snapshot, build the tagged preview. */
|
||||
function report(store, step, regions, exec) {
|
||||
if (step.op === 'delete') return `${step.rel}: deleted.`
|
||||
const key = String((step.destTarget ?? step.target).targetKey)
|
||||
const tag = store.record(key, step.after)
|
||||
const lines = splitLines(step.after).lines
|
||||
const shown = preview(lines, regions ?? [], { context: 2 })
|
||||
const head = formatHeader(step.destRel ?? step.rel, tag)
|
||||
const moved = step.op === 'move' ? ` (moved from ${step.rel})` : ''
|
||||
return [head + moved + (shown.length ? '' : ` — ${lines.length} lines`), ...shown].join('\n')
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- hashline mode
|
||||
|
||||
async function runHashline(args, exec) {
|
||||
if (typeof args.input !== 'string' || !args.input.trim()) throw new EditError('input must be a non-empty hashline patch string.')
|
||||
const store = storeFor(exec)
|
||||
const { sections, warnings } = parseHashline(args.input)
|
||||
const plan = []
|
||||
const anon = { value: null }
|
||||
// Named registers publish only after the whole call lands.
|
||||
const registers = new Map(store.registers)
|
||||
const regionsByStep = new Map()
|
||||
const seen = new Map()
|
||||
for (const sec of sections) {
|
||||
const target = await resolveTarget(sec.path, exec)
|
||||
const key = String(target.targetKey)
|
||||
if (seen.has(key)) throw new EditError(`${sec.path}: appears in two sections; put all of a file's ops in one section.`)
|
||||
seen.set(key, true)
|
||||
const cur = await readFile(target, exec)
|
||||
const curTag = fileTag(cur.text)
|
||||
let ops = sec.ops
|
||||
let baseText = cur.text
|
||||
if (sec.tag !== curTag) {
|
||||
const snap = store.byTag(key, sec.tag)
|
||||
if (!snap) {
|
||||
const others = store.keysWithTag(sec.tag)
|
||||
const hint = others.length ? ` That tag belongs to another file (${others.map((k) => path.basename(k)).join(', ')}).` : ''
|
||||
throw new EditError(`${sec.path}: snapshot tag #${sec.tag} is not current (file is now #${curTag}) and was never issued for this file.${hint} Re-read the file and use its [PATH#TAG] header.`)
|
||||
}
|
||||
const rb = rebaseOps(snap.text, cur.text, ops)
|
||||
if (!rb) {
|
||||
throw new EditError(`${sec.path}: file changed since #${sec.tag} (now #${curTag}) and the anchored lines moved or changed, so the patch was not applied. Re-read the file and resend with the new tag.`)
|
||||
}
|
||||
await editGate(target, exec, cur, { checkVersion: false })
|
||||
ops = rb.ops
|
||||
const off = [...rb.offsets].filter((o) => o !== 0)
|
||||
warnings.push(`${sec.path}: recovered stale tag #${sec.tag} → #${curTag}${off.length ? ` (lines shifted by ${[...new Set(off)].join(', ')})` : ''}.`)
|
||||
} else {
|
||||
await editGate(target, exec, cur, { checkVersion: false })
|
||||
}
|
||||
const { lines, eol } = splitLines(baseText)
|
||||
const res = applySection({ ...sec, ops }, { path: sec.path, lines, registers, anon, warnings })
|
||||
const rel = relPath(target, exec)
|
||||
if (res.rem) { plan.push({ op: 'delete', target, rel, before: cur.text, after: '' }); continue }
|
||||
const after = joinLines(res.lines, eol || res.lines.length > 0)
|
||||
const step = { op: 'update', target, rel, before: cur.text, after, eol: detectEol(cur.raw) }
|
||||
if (res.mv) {
|
||||
const destTarget = await resolveTarget(res.mv, exec)
|
||||
step.op = 'move'; step.destTarget = destTarget; step.destRel = relPath(destTarget, exec)
|
||||
} else if (after === cur.text) {
|
||||
throw new EditError(`${sec.path}: the patch produced no change.`)
|
||||
}
|
||||
regionsByStep.set(step, res.regions)
|
||||
plan.push(step)
|
||||
}
|
||||
const results = await commit(plan, exec)
|
||||
for (const [k, v] of registers) store.registers.set(k, v)
|
||||
const out = plan.map((s) => report(store, s, regionsByStep.get(s), exec))
|
||||
return finish(plan, results, out, warnings)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- replace mode
|
||||
|
||||
async function runReplace(args, exec) {
|
||||
const store = storeFor(exec)
|
||||
const target = await resolveTarget(args.file_path, exec)
|
||||
const cur = await readFile(target, exec)
|
||||
await editGate(target, exec, cur, { checkVersion: true })
|
||||
const rel = relPath(target, exec)
|
||||
const list = Array.isArray(args.edits) && args.edits.length
|
||||
? args.edits
|
||||
: [{ old_string: args.old_string, new_string: args.new_string, replace_all: args.replace_all }]
|
||||
let text = cur.text
|
||||
const warnings = []
|
||||
for (const [i, e] of list.entries()) {
|
||||
if (!isObj(e) || typeof e.old_string !== 'string' || typeof e.new_string !== 'string') throw new EditError(`edits[${i}] needs old_string and new_string strings.`)
|
||||
const r = applyReplace(text, toLF(e.old_string), toLF(e.new_string), { all: !!e.replace_all, fuzzy: cfg.fuzzy, path: rel })
|
||||
if (r.kind !== 'exact') warnings.push(`edit ${i + 1}: matched with ${r.kind} whitespace normalization.`)
|
||||
text = r.text
|
||||
}
|
||||
const step = { op: 'update', target, rel, before: cur.text, after: text, eol: detectEol(cur.raw) }
|
||||
const results = await commit([step], exec)
|
||||
const regions = changedRegions(cur.text, text)
|
||||
return finish([step], results, [report(store, step, regions, exec)], warnings)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- sloppy mode
|
||||
|
||||
async function runSloppy(args, exec) {
|
||||
if (typeof args.input !== 'string' || !args.input.trim()) throw new EditError('input must be a non-empty patch string.')
|
||||
const store = storeFor(exec)
|
||||
const files = parseSloppy(args.input)
|
||||
const plan = []
|
||||
for (const f of files) {
|
||||
const target = await resolveTarget(f.path, exec)
|
||||
const cur = await readFile(target, exec)
|
||||
await editGate(target, exec, cur, { checkVersion: true })
|
||||
const after = applySloppy(cur.text, f)
|
||||
plan.push({ op: 'update', target, rel: relPath(target, exec), before: cur.text, after, eol: detectEol(cur.raw) })
|
||||
}
|
||||
const results = await commit(plan, exec)
|
||||
return finish(plan, results, plan.map((s) => report(store, s, changedRegions(s.before, s.after), exec)), [])
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- apply_patch mode
|
||||
|
||||
async function runApplyPatch(args, exec) {
|
||||
if (typeof args.input !== 'string' || !args.input.trim()) throw new EditError('input must be a non-empty *** Begin Patch string.')
|
||||
const store = storeFor(exec)
|
||||
const ops = parseApplyPatch(args.input)
|
||||
const plan = []
|
||||
const regions = new Map()
|
||||
for (const op of ops) {
|
||||
const target = await resolveTarget(op.path, exec)
|
||||
const rel = relPath(target, exec)
|
||||
if (op.type === 'add') {
|
||||
if (await ctx.fs.stat(target, exec?.signal)) throw new EditError(`${op.path}: already exists; use *** Update File.`)
|
||||
const after = joinLines(op.lines, true)
|
||||
const step = { op: 'create', target, rel, before: '', after }
|
||||
plan.push(step); regions.set(step, [[1, op.lines.length]])
|
||||
continue
|
||||
}
|
||||
const cur = await readFile(target, exec)
|
||||
await editGate(target, exec, cur, { checkVersion: true })
|
||||
if (op.type === 'delete') { plan.push({ op: 'delete', target, rel, before: cur.text, after: '' }); continue }
|
||||
const { lines, eol } = splitLines(cur.text)
|
||||
const res = op.hunks.length ? applyUpdate(lines, op) : { lines, regions: [] }
|
||||
const step = { op: 'update', target, rel, before: cur.text, after: joinLines(res.lines, eol || res.lines.length > 0), eol: detectEol(cur.raw) }
|
||||
if (op.move) { const d = await resolveTarget(op.move, exec); step.op = 'move'; step.destTarget = d; step.destRel = relPath(d, exec) }
|
||||
plan.push(step); regions.set(step, res.regions)
|
||||
}
|
||||
const results = await commit(plan, exec)
|
||||
return finish(plan, results, plan.map((s) => report(store, s, regions.get(s), exec)), [])
|
||||
}
|
||||
|
||||
function changedRegions(before, after) {
|
||||
const d = hunkDiffs('', before, after, 0)
|
||||
const lines = splitLines(after).lines
|
||||
const regions = []
|
||||
// Locate each hunk's new text in the new file to get line numbers.
|
||||
let from = 0
|
||||
for (const h of d) {
|
||||
const first = h.newText.split('\n')[0]
|
||||
let idx = lines.findIndex((l, i) => i >= from && l === first)
|
||||
if (idx < 0) idx = from
|
||||
const len = Math.max(1, h.newText ? h.newText.split('\n').length : 1)
|
||||
regions.push([idx + 1, idx + len])
|
||||
from = idx + len
|
||||
}
|
||||
return regions
|
||||
}
|
||||
|
||||
function finish(plan, results, blocks, warnings) {
|
||||
const text = [...blocks, ...(warnings.length ? ['Warnings:', ...warnings.map((w) => `- ${w}`)] : [])].join('\n\n')
|
||||
const diffs = plan.flatMap((s) => (s.op === 'delete'
|
||||
? [{ path: s.rel, oldText: s.before || null, newText: '' }]
|
||||
: hunkDiffs(s.destRel ?? s.rel, s.before, s.after)))
|
||||
return { text, results, diffs }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- tool definitions
|
||||
|
||||
const textOutput = {
|
||||
schema: { type: 'object', additionalProperties: true, properties: { text: { type: 'string' } } },
|
||||
render: (_args, value) => [{ type: 'text', text: value.text }],
|
||||
presentationMeta: (_args, value) => ({ diffs: value.diffs ?? [] }),
|
||||
}
|
||||
|
||||
const editPresent = {
|
||||
presentCall(args) {
|
||||
return { card: 'diff', title: `Edit${args.file_path ? ` ${args.file_path}` : ''}`, diffs: [] }
|
||||
},
|
||||
presentResult(args, result) {
|
||||
if (result.isError) return undefined
|
||||
const diffs = isObj(result.meta) && Array.isArray(result.meta.diffs) ? result.meta.diffs : []
|
||||
if (!diffs.length) return undefined
|
||||
return { card: 'diff', title: `Edit ${[...new Set(diffs.map((d) => d.path))].join(', ')}`, diffs }
|
||||
},
|
||||
}
|
||||
|
||||
const wrap = (fn) => async (args, exec) => {
|
||||
try {
|
||||
return await fn(args ?? {}, exec)
|
||||
} catch (error) {
|
||||
// EditError / FsError messages are model-facing; rethrow so the runtime marks isError.
|
||||
if (error?.code === 'FS_STALE_VERSION') throw new EditError(`${error.message}. Re-read the file, then retry.`)
|
||||
if (error?.code === 'FS_NOT_OBSERVED') throw new EditError(`${error.message} (read it with \`read\` or \`grep\` first).`)
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
function editTool(mode) {
|
||||
const base = { name: 'edit', output: textOutput, timeoutMs: 120_000, ...editPresent }
|
||||
if (mode === 'hashline') {
|
||||
return {
|
||||
...base,
|
||||
description: P.HASHLINE,
|
||||
parameters: {
|
||||
type: 'object',
|
||||
additionalProperties: false,
|
||||
required: ['input'],
|
||||
properties: { input: { type: 'string', description: 'One or more [PATH#TAG] sections of hashline ops.' } },
|
||||
},
|
||||
execute: wrap(runHashline),
|
||||
}
|
||||
}
|
||||
if (mode === 'sloppy') {
|
||||
return {
|
||||
...base,
|
||||
description: P.SLOPPY,
|
||||
parameters: { type: 'object', additionalProperties: false, required: ['input'], properties: { input: { type: 'string', description: '*** Edit File / *** Find / *** Replace|Insert Before|Insert After payload.' } } },
|
||||
execute: wrap(runSloppy),
|
||||
}
|
||||
}
|
||||
if (mode === 'apply_patch') {
|
||||
return {
|
||||
...base,
|
||||
description: P.APPLY_PATCH,
|
||||
parameters: { type: 'object', additionalProperties: false, required: ['input'], properties: { input: { type: 'string', description: 'The full *** Begin Patch … *** End Patch text.' } } },
|
||||
execute: wrap(runApplyPatch),
|
||||
}
|
||||
}
|
||||
return {
|
||||
...base,
|
||||
description: P.REPLACE,
|
||||
parameters: {
|
||||
type: 'object',
|
||||
additionalProperties: false,
|
||||
required: ['file_path'],
|
||||
properties: {
|
||||
file_path: { type: 'string', description: 'Path of the file to edit.' },
|
||||
old_string: { type: 'string', description: 'Text to replace (fuzzy whitespace matching).' },
|
||||
new_string: { type: 'string', description: 'Replacement text. Empty string deletes.' },
|
||||
replace_all: { type: 'boolean', description: 'Replace every match. Default false (must match once).' },
|
||||
edits: {
|
||||
type: 'array',
|
||||
description: 'Batch: several replacements in this file, applied atomically in order. Use instead of old_string/new_string.',
|
||||
items: {
|
||||
type: 'object',
|
||||
additionalProperties: false,
|
||||
required: ['old_string', 'new_string'],
|
||||
properties: { old_string: { type: 'string' }, new_string: { type: 'string' }, replace_all: { type: 'boolean' } },
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
execute: wrap(async (args, exec) => {
|
||||
if (!(Array.isArray(args.edits) && args.edits.length) && (typeof args.old_string !== 'string' || typeof args.new_string !== 'string')) {
|
||||
throw new EditError('Pass old_string + new_string, or a non-empty edits array.')
|
||||
}
|
||||
return runReplace(args, exec)
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- read / grep wrappers (tag output)
|
||||
|
||||
/** Wrap the built-in read so its output carries a [PATH#TAG] header and LINE:TEXT rows. */
|
||||
function readTool(builtin) {
|
||||
return {
|
||||
...builtin,
|
||||
description: `${builtin.description}${P.READ_HASHLINE_NOTE}`,
|
||||
output: {
|
||||
...builtin.output,
|
||||
schema: { ...builtin.output.schema, properties: { ...builtin.output.schema.properties, tag: { type: 'string' }, rel: { type: 'string' } } },
|
||||
render: (args, value) => {
|
||||
if (!value.tag) return builtin.output.render(args, value)
|
||||
const { tag, rel, ...rest } = value
|
||||
const blocks = builtin.output.render(args, rest)
|
||||
return blocks.map((b) => (b.type === 'text' ? { ...b, text: toHashlineRead(b.text, rel ?? value.path, tag) } : b))
|
||||
},
|
||||
...(builtin.output.presentationMeta ? { presentationMeta: (args, value) => { const { tag: _t, rel: _r, ...rest } = value; return builtin.output.presentationMeta(args, rest) } } : {}),
|
||||
},
|
||||
async execute(args, exec) {
|
||||
const value = await builtin.execute(args, exec)
|
||||
try {
|
||||
const target = await resolveTarget(args.file_path, exec)
|
||||
const { text } = await readFile(target, exec)
|
||||
const tag = storeFor(exec).record(String(target.targetKey), text)
|
||||
return { ...value, tag, rel: relPath(target, exec) }
|
||||
} catch {
|
||||
return value
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
function toHashlineRead(text, displayPath, tag) {
|
||||
return text
|
||||
.replace(/^<path>([^\n]*)<\/path>/, () => `<path>${formatHeader(displayPath, tag)}</path>`)
|
||||
.replace(/^(\d+): /gm, '$1:')
|
||||
}
|
||||
|
||||
/** Wrap the built-in grep: group matches under [PATH#TAG] headers. */
|
||||
function grepTool(builtin) {
|
||||
return {
|
||||
...builtin,
|
||||
description: `${builtin.description}${P.GREP_HASHLINE_NOTE}`,
|
||||
output: {
|
||||
...builtin.output,
|
||||
schema: {
|
||||
...builtin.output.schema,
|
||||
properties: {
|
||||
...builtin.output.schema.properties,
|
||||
tags: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['path', 'tag'], properties: { path: { type: 'string' }, tag: { type: 'string' } } } },
|
||||
},
|
||||
},
|
||||
render: (args, value) => {
|
||||
const { tags: tagList, ...rest } = value
|
||||
if (!tagList || !tagList.length) return builtin.output.render(args, rest)
|
||||
const tags = Object.fromEntries(tagList.map((t) => [t.path, t.tag]))
|
||||
const groups = new Map()
|
||||
for (const m of rest.matches) {
|
||||
if (!groups.has(m.path)) groups.set(m.path, [])
|
||||
groups.get(m.path).push(m)
|
||||
}
|
||||
const max = 250
|
||||
let shown = 0
|
||||
const out = []
|
||||
for (const [p, ms] of groups) {
|
||||
if (shown >= max) break
|
||||
out.push(tags[p] ? formatHeader(p, tags[p]) : p)
|
||||
for (const m of ms) {
|
||||
if (shown++ >= max) break
|
||||
out.push(numbered(m.lineNumber, m.line.length > 400 ? `${m.line.slice(0, 400)}…` : m.line))
|
||||
}
|
||||
}
|
||||
if (rest.matches.length > max) out.push(`(${rest.matches.length - max} more matches not shown; narrow the pattern or path.)`)
|
||||
if (!rest.matches.length) return builtin.output.render(args, rest)
|
||||
return [{ type: 'text', text: out.join('\n') }]
|
||||
},
|
||||
...(builtin.output.presentationMeta ? { presentationMeta: (args, value) => { const { tags: _t, ...rest } = value; return builtin.output.presentationMeta(args, rest) } } : {}),
|
||||
},
|
||||
async execute(args, exec) {
|
||||
const value = await builtin.execute(args, exec)
|
||||
const tags = []
|
||||
try {
|
||||
const store = storeFor(exec)
|
||||
const files = [...new Set((value.matches || []).map((m) => m.path))].slice(0, 60)
|
||||
for (const f of files) {
|
||||
const target = await resolveTarget(f, exec)
|
||||
const { text, version } = await readFile(target, exec)
|
||||
tags.push({ path: f, tag: store.record(String(target.targetKey), text) })
|
||||
// A grep hit counts as an observation of the file (so it can be edited by tag).
|
||||
ctx.emit('fs/observed', target, { kind: 'present', version }, exec)
|
||||
}
|
||||
} catch { /* tagging is best-effort */ }
|
||||
return { ...value, tags }
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- per-agent installation
|
||||
|
||||
const installed = new Map()
|
||||
|
||||
function install(agent) {
|
||||
if (installed.has(agent)) return
|
||||
const scoped = agent.ctx
|
||||
if (!scoped?.tools) return
|
||||
const disposers = []
|
||||
const reg = (d) => { if (typeof d === 'function') disposers.push(d) }
|
||||
let ensure = () => {}
|
||||
try {
|
||||
// Prompt assembly collects the tool schemas for the next request. Wrap read/grep (their
|
||||
// preset may mount after agent/created) before the schemas are built, then align the
|
||||
// edit mode with the model the assembly selected and patch the schema in place.
|
||||
reg(scoped.on('system-prompt/assemble', async (_assembly, _context, next) => {
|
||||
try { ensure() } catch (e) { console.warn(`[omp-edit] wrap read/grep: ${e?.message ?? e}`) }
|
||||
const assembled = await next()
|
||||
const model = assembled?.variables?.model
|
||||
if (model) {
|
||||
const before = modeFor(agent)
|
||||
models.set(agent, `${assembled.variables.provider ?? ''}/${model}`)
|
||||
const after = modeFor(agent)
|
||||
if (after !== before && cfg.replaceEdit) {
|
||||
refreshEdit()
|
||||
const t = editTool(after)
|
||||
return { ...assembled, tools: assembled.tools.map((x) => (x.name === 'edit' ? { ...x, description: t.description, parameters: structuredClone(t.parameters) } : x)) }
|
||||
}
|
||||
}
|
||||
return assembled
|
||||
}, { prepend: true }))
|
||||
reg(scoped.on('agent/request', async (_payload, next) => {
|
||||
const resolved = await next()
|
||||
if (resolved?.model) {
|
||||
const before = modeFor(agent)
|
||||
models.set(agent, `${resolved.provider ?? ''}/${resolved.model}`)
|
||||
if (modeFor(agent) !== before) refreshEdit()
|
||||
}
|
||||
return resolved
|
||||
}))
|
||||
let editDispose = null
|
||||
const refreshEdit = () => {
|
||||
if (!cfg.replaceEdit) return
|
||||
editDispose?.()
|
||||
editDispose = scoped.tools.register(editTool(modeFor(agent)))
|
||||
}
|
||||
if (cfg.replaceEdit) refreshEdit()
|
||||
reg(() => editDispose?.())
|
||||
// read/grep live in the agent's preset scope; wrap them as soon as they are visible
|
||||
// (at creation, or on the first request if the preset mounts later).
|
||||
let wrappedRead = false
|
||||
let wrappedGrep = false
|
||||
const ensureWrappers = () => {
|
||||
if (cfg.replaceRead && !wrappedRead) {
|
||||
const builtin = ctx.tools.get('read', agent)
|
||||
if (builtin && !builtin.__ompWrapped) { const t = readTool(builtin); t.__ompWrapped = true; reg(scoped.tools.register(t)); wrappedRead = true }
|
||||
}
|
||||
if (cfg.replaceGrep && !wrappedGrep) {
|
||||
const builtin = ctx.tools.get('grep', agent)
|
||||
if (builtin && !builtin.__ompWrapped) { const t = grepTool(builtin); t.__ompWrapped = true; reg(scoped.tools.register(t)); wrappedGrep = true }
|
||||
}
|
||||
}
|
||||
ensureWrappers()
|
||||
ensure = ensureWrappers
|
||||
reg(scoped.systemPrompt?.section?.({
|
||||
name: 'omp-edit:hashline',
|
||||
order: scoped.systemPrompt.getSectionOrder('TOOL_EDIT') + 1,
|
||||
text: () => (modeFor(agent) === 'hashline'
|
||||
? 'Edit with hashline: copy the [PATH#TAG] header and LINE numbers from the latest read/grep/edit output; after each edit use the returned header and preview (tags change on every edit).'
|
||||
: ''),
|
||||
}))
|
||||
} catch (error) {
|
||||
for (const d of disposers.splice(0).reverse()) { try { d() } catch {} }
|
||||
console.warn(`[omp-edit] install failed for agent: ${error?.message ?? error}`)
|
||||
return
|
||||
}
|
||||
installed.set(agent, () => { for (const d of disposers.splice(0).reverse()) { try { d() } catch {} } })
|
||||
}
|
||||
|
||||
for (const agent of ctx.agents.list()) install(agent)
|
||||
ctx.on('agent/created', ({ agent }) => { install(agent) })
|
||||
ctx.on('agent/disposed', ({ agent }) => { installed.get(agent)?.(); installed.delete(agent) })
|
||||
ctx.effect(() => () => { for (const d of installed.values()) d(); installed.clear() }, 'omp-edit: scoped tools')
|
||||
}
|
||||
|
||||
// Exposed for tests.
|
||||
export { DEFAULT_WEAK, MODES }
|
||||
Reference in new issue
Block a user