@dotrino/terminal-agent 0.43.1 → 0.44.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +9 -3
- package/bin/terminal.js +57 -2
- package/claude.js +121 -0
- package/package.json +2 -1
- package/skills/hooks/terminal-note-stop.sh +18 -0
- package/skills/hooks/terminal-note-track.sh +17 -0
- package/skills/hooks/terminal-note.sh +14 -0
package/README.md
CHANGED
|
@@ -50,6 +50,7 @@ dotrino-terminal profiles [--json] # los perfiles (agentes con nombre) de
|
|
|
50
50
|
dotrino-terminal link [--name <n>] # enlazar un perfil con tu bóveda
|
|
51
51
|
dotrino-terminal rename <perfil> [nuevo] # renombrarlo (mueve su carpeta y para su agente; mismo aparato)
|
|
52
52
|
dotrino-terminal vscode [--name <n>] # la terminal embebida de VS Code abre consolas de aquí (--off lo deshace)
|
|
53
|
+
dotrino-terminal claude # Claude Code mantiene la tarjeta de su consola: skill + hooks en ~/.claude (--off lo deshace, --status lo dice)
|
|
53
54
|
dotrino-terminal desktop update [--check] # actualiza la app de escritorio: baja, verifica la firma e instala
|
|
54
55
|
dotrino-terminal service install|uninstall|status [--name <n>] # el agente como servicio del usuario
|
|
55
56
|
```
|
|
@@ -76,7 +77,9 @@ Solo esta máquina necesita la 0.38: las otras atienden como a cualquier aparato
|
|
|
76
77
|
VS Code Insiders, VSCodium y Cursor (los que haya, Linux y macOS) y lo deja por defecto; conserva
|
|
77
78
|
los comentarios y el resto del archivo (`editors.js`, con `jsonc-parser`). El perfil apunta a Node
|
|
78
79
|
y al script por su ruta, porque un editor lanzado desde el escritorio no hereda el PATH de la shell:
|
|
79
|
-
al cambiar de Node se vuelve a correr.
|
|
80
|
+
al cambiar de Node se vuelve a correr. En esa terminal (`TERM_PROGRAM=vscode`, sin `--tag`) cerrar
|
|
81
|
+
la pestaña CIERRA la consola: el editor no tiene panel de consolas, y soltarla dejaba una consola
|
|
82
|
+
que nadie mira por cada pestaña cerrada. En cualquier otra ventana se suelta y sigue viva.
|
|
80
83
|
|
|
81
84
|
Enlazar pide una terminal interactiva: se pega la invitación de `dotrino-vault pair` y
|
|
82
85
|
se aprueba con `dotrino-vault approve <código>`. Después puede correr como servicio
|
|
@@ -119,8 +122,11 @@ programa que corre dentro (`--task`). En la tarjeta la tarea se ve y se quita, n
|
|
|
119
122
|
Sin `--id`, es la consola en la que corre la orden: el agente pone su id en
|
|
120
123
|
`DOTRINO_TERMINAL_CONSOLE`. Vive en memoria, como la consola: se va con ella. Hasta 4000 caracteres.
|
|
121
124
|
|
|
122
|
-
Para que un agente de IA la mantenga al día, el paquete trae un skill de Claude Code
|
|
123
|
-
`skills/dotrino-terminal-note
|
|
125
|
+
Para que un agente de IA la mantenga al día, el paquete trae un skill de Claude Code
|
|
126
|
+
(`skills/dotrino-terminal-note/`) y tres hooks (`skills/hooks/`): uno recuerda la tarjeta en cada
|
|
127
|
+
mensaje, otro apunta qué herramientas se usan y el tercero no deja terminar un turno con la tarjeta
|
|
128
|
+
vieja. `dotrino-terminal claude` los pone en `~/.claude` y los engancha en su `settings.json` sin
|
|
129
|
+
tocar lo demás (`claude.js`); `--off` quita exactamente eso. Fuera de una consola no hacen nada.
|
|
124
130
|
|
|
125
131
|
## Imágenes desde otro aparato
|
|
126
132
|
|
package/bin/terminal.js
CHANGED
|
@@ -126,6 +126,9 @@ Cerrar la ventana no cierra la consola: sigue abierta y se retoma después.`, `u
|
|
|
126
126
|
dotrino-terminal vscode [--name <n>] make the integrated terminal of VS Code (and VS Code
|
|
127
127
|
Insiders, VSCodium and Cursor) open consoles from here
|
|
128
128
|
dotrino-terminal vscode --off undo it
|
|
129
|
+
dotrino-terminal claude make Claude Code keep the card of the console it runs
|
|
130
|
+
in up to date (installs a skill and three hooks in ~/.claude)
|
|
131
|
+
dotrino-terminal claude --off undo it (--status says whether it is set)
|
|
129
132
|
dotrino-terminal desktop update update the desktop app (the window): downloads the
|
|
130
133
|
new version, checks its signature and installs it
|
|
131
134
|
(--check only looks for one)
|
|
@@ -248,6 +251,41 @@ function vscode () {
|
|
|
248
251
|
if (!off) console.log(t('\nLas terminales nuevas del editor ya abren aquí. Si actualizas o cambias de Node, vuelve a correr esta orden.', '\nNew terminals in the editor now open here. If you update or switch Node, run this command again.'))
|
|
249
252
|
}
|
|
250
253
|
|
|
254
|
+
/**
|
|
255
|
+
* `dotrino-terminal claude`: que Claude Code mantenga la tarjeta «de qué va» de su consola (el
|
|
256
|
+
* skill y los hooks, `claude.js`). `--off` lo quita; `--status` dice si está puesto.
|
|
257
|
+
*/
|
|
258
|
+
async function claude () {
|
|
259
|
+
const { configureClaude, claudeStatus, HOOKS } = await import('../claude.js')
|
|
260
|
+
if (args.includes('--status')) {
|
|
261
|
+
const s = claudeStatus()
|
|
262
|
+
const all = s.skill && s.hooks.length === HOOKS.length && s.wired.length === HOOKS.length
|
|
263
|
+
const none = !s.skill && !s.hooks.length && !s.wired.length
|
|
264
|
+
if (args.includes('--json')) { console.log(JSON.stringify({ installed: all, ...s })); return }
|
|
265
|
+
console.log(all ? t('Instalado: Claude Code mantiene la tarjeta de sus consolas.', 'Installed: Claude Code keeps the card of its consoles.')
|
|
266
|
+
: none ? t('No está instalado. Se pone con: dotrino-terminal claude', 'Not installed. Set it with: dotrino-terminal claude')
|
|
267
|
+
: t('A medias: vuelve a correr «dotrino-terminal claude» para dejarlo entero.', 'Half set: run "dotrino-terminal claude" again to complete it.'))
|
|
268
|
+
return
|
|
269
|
+
}
|
|
270
|
+
const off = args.includes('--off')
|
|
271
|
+
let done
|
|
272
|
+
try { done = configureClaude({ off }) } catch (e) {
|
|
273
|
+
if (e.code === 'no-claude') die(t('no encontré Claude Code en esta cuenta (no existe ~/.claude). Ábrelo una vez y repite.', 'could not find Claude Code in this account (~/.claude does not exist). Open it once and try again.'))
|
|
274
|
+
if (e.code === 'bad-settings') die(t(`no se pudo leer la configuración de Claude Code y no se tocó nada: ${e.message}`, `could not read Claude Code's settings and nothing was changed: ${e.message}`))
|
|
275
|
+
throw e
|
|
276
|
+
}
|
|
277
|
+
const what = off
|
|
278
|
+
? (done.changed ? t('quitado', 'removed') : t('no estaba', 'was not set'))
|
|
279
|
+
: (done.changed ? t('instalado', 'installed') : t('ya estaba', 'already set'))
|
|
280
|
+
console.log(` Claude Code ${what}`)
|
|
281
|
+
if (!off) {
|
|
282
|
+
console.log(` ${done.skill}`)
|
|
283
|
+
for (const h of done.hooks) console.log(` ${h}`)
|
|
284
|
+
console.log(` ${done.settings}`)
|
|
285
|
+
console.log(t('\nLas sesiones NUEVAS de Claude Code dentro de una consola de Dotrino Terminal ya mantienen su tarjeta. Fuera de una consola no hace nada.', '\nNEW Claude Code sessions inside a Dotrino Terminal console now keep its card. Outside a console it does nothing.'))
|
|
286
|
+
}
|
|
287
|
+
}
|
|
288
|
+
|
|
251
289
|
/**
|
|
252
290
|
* Qué versiones nuevas hay, sin instalar nada: del cliente (npm) y, con `--desktop <versión>`,
|
|
253
291
|
* de la app de escritorio. La app lo pregunta al arrancar (ella no tiene red). Cada una dice
|
|
@@ -851,7 +889,11 @@ function interactive (conn, first, dir) {
|
|
|
851
889
|
if (ch === 'p') { conn.send({ type: 'resize', ...size() }); conn.send({ type: 'take' }); continue }
|
|
852
890
|
if (ch === 'n') {
|
|
853
891
|
if (send) { input(send); send = '' }
|
|
854
|
-
|
|
892
|
+
// En otra máquina (`--machine`) la carpeta de aquí no existe: sin `--cwd`, la consola
|
|
893
|
+
// nueva abre en su carpeta de inicio. Mandar la de aquí hacía que la rechazara
|
|
894
|
+
// (`bad-cwd`) y la ventana acababa en otra consola en vez de en una nueva.
|
|
895
|
+
const where = opt('--machine') ? (first.cwd ? { cwd: first.cwd } : {}) : { cwd: first.cwd || path.resolve(process.cwd()) }
|
|
896
|
+
switchTo({ type: 'open', ...where })
|
|
855
897
|
continue
|
|
856
898
|
}
|
|
857
899
|
send += ch === DETACH_PREFIX ? ch : DETACH_PREFIX + ch
|
|
@@ -865,7 +907,19 @@ function interactive (conn, first, dir) {
|
|
|
865
907
|
for (const b of early.splice(0)) onKeys(b)
|
|
866
908
|
out.on('resize', () => conn.send({ type: 'resize', ...size() }))
|
|
867
909
|
// La ventana se cerró: el agente ve caer la conexión y suelta la consola (sigue viva).
|
|
868
|
-
|
|
910
|
+
// SALVO en la terminal integrada de VS Code (y Cursor, VSCodium: `TERM_PROGRAM=vscode`): allí
|
|
911
|
+
// no hay panel de consolas con el que volver a ella ni cerrarla, así que cada terminal cerrada
|
|
912
|
+
// dejaba una consola que nadie mira (dueño, 2026-10-13). Cerrar la terminal CIERRA su consola.
|
|
913
|
+
// Una ventana de la app (`--tag`) nunca: aunque la app se lanzara desde una terminal de VS Code.
|
|
914
|
+
const ownsConsole = process.env.TERM_PROGRAM === 'vscode' && !opt('--tag')
|
|
915
|
+
for (const sig of ['SIGHUP', 'SIGTERM']) {
|
|
916
|
+
process.on(sig, () => {
|
|
917
|
+
if (!ownsConsole || !consoleId) { conn.close(); process.exit(0) }
|
|
918
|
+
conn.send({ type: 'close' })
|
|
919
|
+
// Que la orden salga antes de soltar la conexión.
|
|
920
|
+
setTimeout(() => { conn.close(); process.exit(0) }, 150)
|
|
921
|
+
})
|
|
922
|
+
}
|
|
869
923
|
|
|
870
924
|
conn.send({ ...first, ...size() })
|
|
871
925
|
}
|
|
@@ -876,6 +930,7 @@ try {
|
|
|
876
930
|
if (cmd === 'rename') { await rename(); process.exit(0) }
|
|
877
931
|
if (cmd === 'lock') { await lock(); process.exit(0) }
|
|
878
932
|
if (cmd === 'vscode') { vscode(); process.exit(0) }
|
|
933
|
+
if (cmd === 'claude') { await claude(); process.exit(0) }
|
|
879
934
|
if (cmd === 'desktop') { await desktop(); process.exit(0) }
|
|
880
935
|
if (cmd === 'updates') { await updates(); process.exit(0) }
|
|
881
936
|
if (cmd === 'service') { await service(); process.exit(0) }
|
package/claude.js
ADDED
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* claude.js — que Claude Code mantenga al día la tarjeta «de qué va» de su consola.
|
|
3
|
+
*
|
|
4
|
+
* `dotrino-terminal claude` deja en la carpeta de Claude Code del usuario (`~/.claude`):
|
|
5
|
+
* · el skill `dotrino-terminal-note` (cómo se usa `dotrino-terminal note --task`);
|
|
6
|
+
* · tres hooks, y sus entradas en `settings.json`: uno recuerda la tarjeta en cada mensaje, otro
|
|
7
|
+
* apunta qué herramientas se usan, y el tercero no deja terminar un turno con la tarjeta vieja.
|
|
8
|
+
* `--off` quita exactamente eso. Fuera de una consola de Dotrino Terminal los hooks no hacen nada.
|
|
9
|
+
*
|
|
10
|
+
* Es la misma idea que `editors.js` con VS Code: una orden que se puede repetir y deshacer, y que
|
|
11
|
+
* no toca lo demás del archivo del usuario.
|
|
12
|
+
*/
|
|
13
|
+
import fs from 'node:fs'
|
|
14
|
+
import os from 'node:os'
|
|
15
|
+
import path from 'node:path'
|
|
16
|
+
import { fileURLToPath } from 'node:url'
|
|
17
|
+
|
|
18
|
+
export const SKILL = 'dotrino-terminal-note'
|
|
19
|
+
/** Cada hook: su archivo y el evento de Claude Code en que corre. */
|
|
20
|
+
export const HOOKS = [
|
|
21
|
+
{ file: 'terminal-note.sh', event: 'UserPromptSubmit' },
|
|
22
|
+
{ file: 'terminal-note-track.sh', event: 'PreToolUse' },
|
|
23
|
+
{ file: 'terminal-note-stop.sh', event: 'Stop' },
|
|
24
|
+
]
|
|
25
|
+
|
|
26
|
+
const fail = (code, message) => Object.assign(new Error(message), { code })
|
|
27
|
+
const source = () => path.join(path.dirname(fileURLToPath(import.meta.url)), 'skills')
|
|
28
|
+
|
|
29
|
+
/** ¿Es `command` el hook `file`? Por el archivo, lo llame como lo llame (con o sin comillas). */
|
|
30
|
+
const runs = (command, file) => typeof command === 'string' && new RegExp(`[/\\\\]hooks[/\\\\]${file.replace(/\./g, '\\.')}(["'\\s]|$)`).test(command)
|
|
31
|
+
|
|
32
|
+
function readSettings (file) {
|
|
33
|
+
if (!fs.existsSync(file)) return {}
|
|
34
|
+
let value
|
|
35
|
+
try { value = JSON.parse(fs.readFileSync(file, 'utf8')) } catch (e) { throw fail('bad-settings', `${file}: ${e.message}`) }
|
|
36
|
+
if (!value || typeof value !== 'object' || Array.isArray(value)) throw fail('bad-settings', `${file}: not an object`)
|
|
37
|
+
return value
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
/** `settings` sin las entradas de nuestros hooks (y sin los grupos o eventos que queden vacíos). */
|
|
41
|
+
function withoutHooks (settings) {
|
|
42
|
+
const hooks = settings.hooks
|
|
43
|
+
if (!hooks || typeof hooks !== 'object') return settings
|
|
44
|
+
const out = {}
|
|
45
|
+
for (const [event, groups] of Object.entries(hooks)) {
|
|
46
|
+
if (!Array.isArray(groups)) { out[event] = groups; continue }
|
|
47
|
+
const kept = groups
|
|
48
|
+
.map((g) => (Array.isArray(g?.hooks) ? { ...g, hooks: g.hooks.filter((h) => !HOOKS.some((x) => runs(h?.command, x.file))) } : g))
|
|
49
|
+
.filter((g) => !Array.isArray(g?.hooks) || g.hooks.length)
|
|
50
|
+
if (kept.length) out[event] = kept
|
|
51
|
+
}
|
|
52
|
+
const next = { ...settings, hooks: out }
|
|
53
|
+
if (!Object.keys(out).length) delete next.hooks
|
|
54
|
+
return next
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
/** ¿Está puesto? `{ skill, hooks: [archivos presentes], wired: [archivos con entrada en settings] }`. */
|
|
58
|
+
export function claudeStatus ({ home = os.homedir() } = {}) {
|
|
59
|
+
const dir = path.join(home, '.claude')
|
|
60
|
+
let settings = {}
|
|
61
|
+
try { settings = readSettings(path.join(dir, 'settings.json')) } catch (_) {}
|
|
62
|
+
const commands = Object.values(settings.hooks || {}).flat().flatMap((g) => g?.hooks || []).map((h) => h?.command)
|
|
63
|
+
return {
|
|
64
|
+
skill: fs.existsSync(path.join(dir, 'skills', SKILL, 'SKILL.md')),
|
|
65
|
+
hooks: HOOKS.filter((h) => fs.existsSync(path.join(dir, 'hooks', h.file))).map((h) => h.file),
|
|
66
|
+
wired: HOOKS.filter((h) => commands.some((c) => runs(c, h.file))).map((h) => h.file),
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
/**
|
|
71
|
+
* Pone (o con `off`, quita) el skill y los hooks. Devuelve qué cambió.
|
|
72
|
+
* Sin `~/.claude` no hay Claude Code en esta cuenta: se dice (`no-claude`) y no se crea nada.
|
|
73
|
+
* Un `settings.json` que no se puede leer no se toca (`bad-settings`).
|
|
74
|
+
*/
|
|
75
|
+
export function configureClaude ({ off = false, home = os.homedir(), from = source() } = {}) {
|
|
76
|
+
const dir = path.join(home, '.claude')
|
|
77
|
+
if (!fs.existsSync(dir)) throw fail('no-claude', `${dir} does not exist`)
|
|
78
|
+
const settingsFile = path.join(dir, 'settings.json')
|
|
79
|
+
const before = readSettings(settingsFile)
|
|
80
|
+
const skillDir = path.join(dir, 'skills', SKILL)
|
|
81
|
+
const hooksDir = path.join(dir, 'hooks')
|
|
82
|
+
|
|
83
|
+
// Lo que ya está enganchado (lo llame como lo llame) se deja como está: no se duplica ni se mueve.
|
|
84
|
+
const wired = (file) => Object.values(before.hooks || {}).flat().flatMap((g) => g?.hooks || []).some((h) => runs(h?.command, file))
|
|
85
|
+
let next = before
|
|
86
|
+
if (off) next = withoutHooks(before)
|
|
87
|
+
else {
|
|
88
|
+
const hooks = { ...(before.hooks || {}) }
|
|
89
|
+
for (const h of HOOKS.filter((x) => !wired(x.file))) {
|
|
90
|
+
const file = path.join(hooksDir, h.file)
|
|
91
|
+
const command = `bash ${/\s/.test(file) ? JSON.stringify(file) : file}`
|
|
92
|
+
hooks[h.event] = [...(Array.isArray(hooks[h.event]) ? hooks[h.event] : []), { hooks: [{ type: 'command', command, timeout: 5 }] }]
|
|
93
|
+
}
|
|
94
|
+
next = { ...before, hooks }
|
|
95
|
+
}
|
|
96
|
+
const settingsChanged = JSON.stringify(before) !== JSON.stringify(next)
|
|
97
|
+
|
|
98
|
+
let filesChanged = false
|
|
99
|
+
if (off) {
|
|
100
|
+
for (const h of HOOKS) { const f = path.join(hooksDir, h.file); if (fs.existsSync(f)) { fs.rmSync(f); filesChanged = true } }
|
|
101
|
+
if (fs.existsSync(skillDir)) { fs.rmSync(skillDir, { recursive: true }); filesChanged = true }
|
|
102
|
+
} else {
|
|
103
|
+
const put = (src, dest, mode) => {
|
|
104
|
+
const want = fs.readFileSync(src)
|
|
105
|
+
if (fs.existsSync(dest) && fs.readFileSync(dest).equals(want)) return
|
|
106
|
+
fs.mkdirSync(path.dirname(dest), { recursive: true })
|
|
107
|
+
fs.writeFileSync(dest, want, { mode })
|
|
108
|
+
fs.chmodSync(dest, mode)
|
|
109
|
+
filesChanged = true
|
|
110
|
+
}
|
|
111
|
+
put(path.join(from, SKILL, 'SKILL.md'), path.join(skillDir, 'SKILL.md'), 0o644)
|
|
112
|
+
for (const h of HOOKS) put(path.join(from, 'hooks', h.file), path.join(hooksDir, h.file), 0o755)
|
|
113
|
+
}
|
|
114
|
+
if (settingsChanged) {
|
|
115
|
+
// De una vez (temporal + renombrar): Claude Code lee este archivo en cada sesión.
|
|
116
|
+
const tmp = `${settingsFile}.dotrino-${process.pid}`
|
|
117
|
+
fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n')
|
|
118
|
+
fs.renameSync(tmp, settingsFile)
|
|
119
|
+
}
|
|
120
|
+
return { changed: settingsChanged || filesChanged, settings: settingsFile, skill: skillDir, hooks: HOOKS.map((h) => path.join(hooksDir, h.file)) }
|
|
121
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@dotrino/terminal-agent",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.44.0",
|
|
4
4
|
"description": "Dotrino Terminal: las ventanas de esta máquina (dotrino-terminal) y su agente, que deja abrir esas mismas consolas desde los otros aparatos de tu cuenta, cifrado punto a punto.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"bin": {
|
|
@@ -15,6 +15,7 @@
|
|
|
15
15
|
"access.js",
|
|
16
16
|
"far.js",
|
|
17
17
|
"editors.js",
|
|
18
|
+
"claude.js",
|
|
18
19
|
"consoles.js",
|
|
19
20
|
"desktop.js",
|
|
20
21
|
"link.js",
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
# Stop: dentro de una consola de Dotrino Terminal, no deja terminar el turno con la tarjeta
|
|
3
|
+
# vieja. Si en este turno se usaron herramientas y la tarea no se puso DESPUÉS de la última, la
|
|
4
|
+
# tarjeta dice algo que ya no es cierto («Ahora: compilando» con todo terminado): se le devuelve
|
|
5
|
+
# a Claude para que la ponga al día. Una sola vez por parada (stop_hook_active), sin bucles.
|
|
6
|
+
[ -n "$DOTRINO_TERMINAL_CONSOLE" ] || exit 0
|
|
7
|
+
command -v dotrino-terminal >/dev/null 2>&1 || exit 0
|
|
8
|
+
input=$(cat)
|
|
9
|
+
case "$input" in *'"stop_hook_active":true'*|*'"stop_hook_active": true'*) exit 0 ;; esac
|
|
10
|
+
key="$HOME/.claude/hooks/state/note-$DOTRINO_TERMINAL_CONSOLE"
|
|
11
|
+
prompt=$(cat "$key.prompt" 2>/dev/null || echo 0)
|
|
12
|
+
tool=$(cat "$key.tool" 2>/dev/null || echo 0)
|
|
13
|
+
task=$(cat "$key.task" 2>/dev/null || echo 0)
|
|
14
|
+
# Sin herramientas en este turno no cambió nada: la tarjeta sigue valiendo.
|
|
15
|
+
[ "$tool" -gt "$prompt" ] || exit 0
|
|
16
|
+
[ "$task" -gt "$tool" ] && exit 0
|
|
17
|
+
echo "La tarjeta de esta consola quedó vieja: en este turno hiciste cosas y no pusiste la tarea después. Antes de terminar, ponla al día con \`dotrino-terminal note --task\` (lo que quedó hecho, y si terminaste o qué esperas; nada de «Ahora:» que ya no ocurre). Solo --task; no lo anuncies." >&2
|
|
18
|
+
exit 2
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
# PreToolUse (todas las herramientas): dentro de una consola de Dotrino Terminal, apunta cuándo
|
|
3
|
+
# fue la última herramienta usada y cuándo la última vez que se puso la tarea de la tarjeta
|
|
4
|
+
# (`dotrino-terminal note --task`). Con eso, terminal-note-stop.sh sabe si la tarjeta quedó vieja.
|
|
5
|
+
[ -n "$DOTRINO_TERMINAL_CONSOLE" ] || exit 0
|
|
6
|
+
dir="$HOME/.claude/hooks/state"; key="$dir/note-$DOTRINO_TERMINAL_CONSOLE"
|
|
7
|
+
mkdir -p "$dir"
|
|
8
|
+
input=$(cat)
|
|
9
|
+
n=$(( $(cat "$key.n" 2>/dev/null || echo 0) + 1 )); echo "$n" > "$key.n"
|
|
10
|
+
case "$input" in
|
|
11
|
+
*'"tool_name":"Bash"'*|*'"tool_name": "Bash"'*)
|
|
12
|
+
case "$input" in
|
|
13
|
+
*'note --task'*) echo "$n" > "$key.task"; exit 0 ;;
|
|
14
|
+
esac ;;
|
|
15
|
+
esac
|
|
16
|
+
echo "$n" > "$key.tool"
|
|
17
|
+
exit 0
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
# UserPromptSubmit: dentro de una consola de Dotrino Terminal, recuerda en cada mensaje que la
|
|
3
|
+
# tarjeta «de qué va» se mantiene al día. Fuera de una consola no dice nada.
|
|
4
|
+
# Lo instala `dotrino-terminal claude` (y lo quita `dotrino-terminal claude --off`).
|
|
5
|
+
[ -n "$DOTRINO_TERMINAL_CONSOLE" ] || exit 0
|
|
6
|
+
command -v dotrino-terminal >/dev/null 2>&1 || exit 0
|
|
7
|
+
# En qué momento empezó este turno (lo usa terminal-note-stop.sh). Un contador, no la hora: el
|
|
8
|
+
# `date` de macOS no da fracciones de segundo, y dos cosas en el mismo segundo no se ordenarían.
|
|
9
|
+
dir="$HOME/.claude/hooks/state"; key="$dir/note-$DOTRINO_TERMINAL_CONSOLE"
|
|
10
|
+
mkdir -p "$dir"
|
|
11
|
+
n=$(( $(cat "$key.n" 2>/dev/null || echo 0) + 1 )); echo "$n" > "$key.n"; echo "$n" > "$key.prompt"
|
|
12
|
+
cat <<'MSG'
|
|
13
|
+
[Dotrino Terminal] Esta sesión corre en una consola con tarjeta «de qué va». Mantén la tarea al día con `dotrino-terminal note --task … --title '<de qué va, en pocas palabras>'` (skill dotrino-terminal-note; el título es el nombre de la consola: el mismo mientras la tarea sea la misma, otro cuando cambie): al empezar lo que pide este mensaje, CADA VEZ que pase algo (un paso terminado, algo publicado, un fallo, un cambio de rumbo, quedar esperando algo) y al terminar. La última línea, siempre: `Modelo: <el modelo que eres>`. Solo `--task` y `--title`: las notas personales del dueño no se tocan. Sin anunciarlo en la respuesta.
|
|
14
|
+
MSG
|