@ssebastien/tcmd 0.1.3 → 0.1.7

package/src/js/tcmd/core/permissions.js

@@ -0,0 +1,107 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-22
+
+// Module: tcmd/core/permissions
+// POSIX permission bits as the command panel edits them: the nine `u/g/o` ×
+// `r/w/x` toggles `chmod` binds its MODE argument to. The tables are the single
+// source of truth for the display order, the octal values and the `rwx`
+// rendering; the panel projects them into rows and the argument row component
+// renders the three cells of each class.
+//
+// Everything here is pure: the binding is the caller's, and the numeric/octal
+// conversions do not mutate it.
+
+// Constant: PERMISSION_CLASSES
+// The permission classes in display order (owner, group, other).
+const PERMISSION_CLASSES = [
+	{ id: "u", label: "user" },
+	{ id: "g", label: "group" },
+	{ id: "o", label: "other" },
+]
+
+// Constant: PERMISSION_BITS
+// The bits of each class in display order (read, write, execute).
+const PERMISSION_BITS = [
+	{ id: "r", label: "read" },
+	{ id: "w", label: "write" },
+	{ id: "x", label: "execute" },
+]
+
+// Constant: PERMISSION_VALUES
+// The octal value of each `class:bit` key.
+const PERMISSION_VALUES = {
+	"u:r": 0o400, "u:w": 0o200, "u:x": 0o100,
+	"g:r": 0o040, "g:w": 0o020, "g:x": 0o010,
+	"o:r": 0o004, "o:w": 0o002, "o:x": 0o001,
+}
+
+// Function: permissionItems
+// The nine `u/g/o` × `r/w/x` toggles for a permission argument, seeded from an
+// existing file mode. Each item is a checkbox in the panel's item list: its
+// `key` is the stable `class:bit` key the token builder reads back.
+function permissionItems(mode) {
+	const bits = Number(mode) & 0o777
+	const items = []
+	for (const permissionClass of PERMISSION_CLASSES) {
+		for (const bit of PERMISSION_BITS) {
+			const key = `${permissionClass.id}:${bit.id}`
+			items.push({
+				key,
+				name: bit.label,
+				parent: permissionClass.label,
+				isDir: false,
+				selected: (bits & PERMISSION_VALUES[key]) !== 0,
+			})
+		}
+	}
+	return items
+}
+
+// Function: permissionMode
+// The numeric mode a permission binding currently selects.
+function permissionMode(binding) {
+	let mode = 0
+	for (const item of binding?.items ?? []) {
+		if (item.selected) mode |= PERMISSION_VALUES[item.key] ?? 0
+	}
+	return mode
+}
+
+// Function: permissionOctal
+// The three-digit octal token a permission binding contributes to argv.
+function permissionOctal(binding) {
+	return permissionMode(binding).toString(8).padStart(3, "0")
+}
+
+// Function: permissionSymbolic
+// The `rwx`-style rendering of a numeric mode.
+function permissionSymbolic(mode) {
+	return PERMISSION_CLASSES.map((permissionClass) =>
+		PERMISSION_BITS.map((bit) =>
+			mode & PERMISSION_VALUES[`${permissionClass.id}:${bit.id}`] ? bit.id : "-",
+		).join(""),
+	).join("")
+}
+
+// Function: permissionText
+// The binding's value as the panel shows it: the octal mode and its symbolic
+// form (`644 · rw-r--r--`).
+function permissionText(binding) {
+	const mode = permissionMode(binding)
+	return `${permissionOctal(binding)} · ${permissionSymbolic(mode)}`
+}
+
+export {
+	PERMISSION_BITS,
+	PERMISSION_CLASSES,
+	PERMISSION_VALUES,
+	permissionItems,
+	permissionMode,
+	permissionOctal,
+	permissionSymbolic,
+	permissionText,
+}
+
+// EOF

package/src/js/tcmd/core/picker.js

@@ -0,0 +1,156 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-22
+
+// Module: tcmd/core/picker
+// The command panel's file picker: the private pane the panel browses while a
+// `dest`/`path` argument is being filled. The picker owns its editable path
+// text, the directory that text resolves against, the visible listing and the
+// queue that keeps fast typing from landing an older navigation after a newer
+// one. State cells live on the session (see `core/session`); this module holds
+// the path rules and the row shaping so `core/panel` stays about argument
+// binding.
+
+import { basename, join, normalize, parent } from "./path.js"
+
+// Function: pickerAbsolutePath
+// Resolves the picker's editable path text: `~`, an absolute path, or a path
+// relative to `base` (the directory the picker was opened from).
+function pickerAbsolutePath(text, base = "/", home = "/") {
+	const raw = `${text ?? ""}`
+	if (!raw) return normalize(base || "/")
+	if (raw === "~") return normalize(home || "/")
+	if (raw.startsWith("~/")) return join(home, raw.slice(2))
+	if (raw.startsWith("/")) return normalize(raw)
+	return join(base || "/", raw)
+}
+
+// Function: pickerDirectoryText
+// The path input's display form: a trailing slash marks a directory, so typing
+// after it starts a child name (the same affordance a shell prompt gives).
+function pickerDirectoryText(path) {
+	const normalized = normalize(path)
+	return normalized === "/" ? "/" : `${normalized}/`
+}
+
+// Function: resolvePickerPath
+// Interprets the editable path text as `{ directory, query }`: an existing
+// directory lists its contents, an existing file keeps its parent listing with
+// the file as the filter, and a missing path walks up to the closest existing
+// directory while the dropped segment becomes the filter. This is what makes
+// typing `/home/do` show the matching entries under `/home`.
+async function resolvePickerPath(fs, text, base = "/", home = "/") {
+	const raw = `${text ?? ""}`
+	const absolute = pickerAbsolutePath(raw, base, home)
+	const stats = await fs.stat(absolute)
+	if (stats?.isDir) return { directory: absolute, query: "" }
+	if (stats) return { directory: parent(absolute) ?? "/", query: basename(absolute) }
+
+	const trailing = raw.endsWith("/")
+	let directory = trailing ? absolute : parent(absolute) ?? "/"
+	const rest = trailing ? [] : [basename(absolute)]
+	while (directory !== "/") {
+		if ((await fs.stat(directory))?.isDir) break
+		rest.unshift(basename(directory))
+		directory = parent(directory) ?? "/"
+	}
+	return { directory, query: rest[0] ?? "" }
+}
+
+// Function: pickerVisibleEntries
+// The entries the picker lists for a mode: a destination picker lists
+// directories only, so every row is a valid choice; a file/any picker keeps the
+// listing intact, where a directory row descends.
+function pickerVisibleEntries(entries, mode) {
+	return mode === "dir" ? (entries ?? []).filter((entry) => entry.isDir) : entries ?? []
+}
+
+// Function: pickerRowList
+// Flattens the picker's visible listing into the rows the picker renders. The
+// `..` parent navigation row stays at the top when filtering and is omitted at
+// the filesystem root; entry rows keep the listing details (size, mode, link
+// target) so they render exactly like a file panel.
+function pickerRowList(entries, path) {
+	const rows = []
+	const parentPath = parent(path)
+	if (parentPath) {
+		rows.push({
+			type: "parent",
+			key: `parent:${path}`,
+			name: "..",
+			path: parentPath,
+			isDir: true,
+			isSymlink: false,
+			isDevice: false,
+			isParent: true,
+			target: null,
+			size: 0,
+			mode: 0,
+			ext: null,
+		})
+	}
+	for (const entry of entries ?? []) {
+		rows.push({ ...entry, type: "entry", key: entry.path })
+	}
+	return rows
+}
+
+// Function: createPickerPathQueue
+// Creates the picker's path-resolution queue for one session. `invalidate`
+// drops any queued work before an explicit navigation or close; `schedule`
+// resolves one path text and applies the resulting directory and filter. Work
+// is serialized so fast typing cannot land an older navigation after a newer
+// one, and a token drops every intermediate keystroke.
+function createPickerPathQueue(session) {
+	let version = 0
+	let queue = Promise.resolve()
+	return {
+		invalidate() {
+			version += 1
+		},
+		schedule(text) {
+			if (!session.pickerOpen.value) return
+			const token = ++version
+			queue = queue
+				.then(async () => {
+					if (token !== version || !session.pickerOpen.value) return
+					const base = session.pickerBasePath.value || session.pickerPane.path.value || "/"
+					const { directory, query } = await resolvePickerPath(
+						session.fs,
+						text,
+						base,
+						session.fs.home?.() ?? "/",
+					)
+					if (token !== version || session.pickerPathText.value !== text) return
+					if (session.pickerPane.path.value !== directory) {
+						await session.pickerPane.navigate(directory, { record: false })
+					}
+					if (token !== version || session.pickerPathText.value !== text) return
+					session.pickerQuery.set(query)
+					const rows = session.pickerRows.value
+					const firstMatch = query ? rows.findIndex((row) => row.type === "entry") : 0
+					session.panelRowIndex.set(firstMatch >= 0 ? firstMatch : 0)
+				})
+				.catch((error) => {
+					// Keep the queue alive after an unreadable path; the picker
+					// keeps the last listing and the command bar reports what
+					// failed.
+					if (token === version) {
+						session.notice?.set({ kind: "warning", text: `${error?.message ?? error}` })
+					}
+				})
+		},
+	}
+}
+
+export {
+	createPickerPathQueue,
+	pickerAbsolutePath,
+	pickerDirectoryText,
+	pickerRowList,
+	pickerVisibleEntries,
+	resolvePickerPath,
+}
+
+// EOF

package/src/js/tcmd/core/preview.js

@@ -0,0 +1,102 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-16
+
+// Module: tcmd/core/preview
+// Preview classification and payload helpers, shared by the session's preview
+// effect and by the commands that need to know how an entry previews — Enter
+// opens a text file in `$EDITOR` and everything else in the fullscreen
+// inspector (see `core/commands`). Pure and renderer-free: `previewKind` maps
+// a resolved extension to a preview kind, `previewSource` resolves what a
+// symlink previews *through* (and what a compressed file decompresses *to*),
+// and `hasBinaryByte` is the content sniff that turns a text head into a
+// metadata card.
+
+import { basename, extname } from "./path.js"
+
+// Constant: PREVIEW_BYTES / SNIFF_BYTES
+// Bytes of a text file the inspector reads for its inline body — the head
+// budget every filesystem adapter defaults to — and the shorter opening run
+// `hasBinaryByte` sniffs to call a body binary.
+const PREVIEW_BYTES = 65536
+const SNIFF_BYTES = 2048
+
+// Constant: IMAGE_EXTS / MEDIA_EXTS
+// Extensions with a dedicated (non-text) preview: they render as a metadata
+// card, never as an editable text body.
+const IMAGE_EXTS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "svg"]
+const MEDIA_EXTS = ["mp3", "wav", "ogg", "flac", "mp4", "webm", "mkv", "mov", "pdf"]
+
+// Constant: COMPRESSION_EXTS
+// Single-file compression formats the inspector decompresses before sniffing
+// the body. The compressed entry keeps its own extension in the header; the
+// name inside (`notes.txt` in `notes.txt.gz`) supplies the kind, the syntax
+// filetype and the badge's inner label.
+const COMPRESSION_EXTS = new Map([
+	["gz", "gzip"],
+	["bz2", "bzip2"],
+])
+
+// Function: compressionOf
+// Decompressor for a resolved extension ("gzip"/"bzip2"), or null when the
+// entry is not compressed.
+function compressionOf(ext) {
+	return ext ? COMPRESSION_EXTS.get(ext) ?? null : null
+}
+
+// Function: previewKind
+// Preview classification for a resolved file extension; directories are not
+// previewed (the caller passes their `null` ext). Takes the extension rather
+// than the entry so a symlink classifies as what it points at.
+function previewKind(ext) {
+	if (ext && IMAGE_EXTS.includes(ext)) return "image"
+	if (ext && MEDIA_EXTS.includes(ext)) return "media"
+	return "text"
+}
+
+// Function: hasBinaryByte
+// Content sniff: a text file's head carries no control byte in its opening
+// run, so a hit here means the body is binary and previews as a card.
+function hasBinaryByte(text) {
+	for (let i = 0; i < SNIFF_BYTES && i < text.length; i++) {
+		const code = text.charCodeAt(i)
+		if (code < 9 || (code > 13 && code < 32)) return true
+	}
+	return false
+}
+
+// Function: previewSource
+// What the preview renders *through* a symlink, and what a compressed file
+// decompresses to: `title` names the traversal (`notes -> ../real/notes`) so
+// it is visible in the header; `ext` is the entry's (target's) own extension;
+// `innerName`/`innerExt` strip a `.gz`/`.bz2` suffix so `notes.txt.gz`
+// previews with the kind, filetype and badge of `notes.txt`; `compression` is
+// the decompressor the session applies, or null. Plain entries pass through
+// with `innerName === name` and `innerExt === ext`.
+function previewSource(entry) {
+	const target = entry?.isSymlink && entry.target ? `${entry.target}` : null
+	const name = target ? basename(target) : basename(entry?.path ?? "")
+	const ext = extname(name) ?? entry?.ext ?? null
+	const compression = compressionOf(ext)
+	const innerName = compression ? name.slice(0, name.lastIndexOf(".")) : name
+	const innerExt = compression ? extname(innerName) : ext
+	return {
+		title: target ? `${basename(entry.path)} -> ${target}` : name,
+		ext,
+		innerName,
+		innerExt,
+		compression,
+	}
+}
+
+export {
+	compressionOf,
+	hasBinaryByte,
+	PREVIEW_BYTES,
+	previewKind,
+	previewSource,
+	SNIFF_BYTES,
+}
+
+// EOF

package/src/js/tcmd/core/script.js

@@ -4,13 +4,13 @@
 // Created: 2026-09-27
 
 // Module: tcmd/core/script
-// The scripting language behind the command palette's scripting mode (`:`):
-// line tokenizer, operation parser and runner, plus the completion rows the
-// palette lists. A line starts with an operation name (or the `!` alias for
-// `run`); arguments may be filesets ($A, $B, $FILE), quoted paths, `~` or
-// paths relative to the active pane.
+// The TinyCmd scripting language: line tokenizer, operation parser and runner.
+// A line starts with an operation name (or the `!` alias for `run`); arguments
+// may be filesets ($A, $B, $FILE), quoted paths, `~` or paths relative to the
+// active pane. The command panel runs operations structurally and delegates to
+// the same `runLine` through `runOperation`.
 
-import { getOperation, getOperations, humanSize, runOperation } from "./operations.js"
+import { getOperation, runOperation } from "./operations.js"
 
 // Function: tokenize
 // Whitespace tokenizer with single/double quotes and backslash escapes.
@@ -93,94 +93,6 @@ async function runLine(session, line, options = {}) {
 	return runOperation(session, parsed.op, parsed.args, { ...options, line })
 }
 
-// Function: scriptItems
-// Palette rows for scripting mode: the session's available filesets first,
-// then every operation, then matching entries of the active pane (path
-// completion). Rows carry the full query replacement `completion` for Tab.
-function scriptItems(query, filesets, context = {}) {
-	const text = `${query ?? ""}`
-	const q = text.trim().toLowerCase()
-	const head = q.split(/\s+/)[0] ?? ""
-	const rows = []
-	const typingFileset = lastToken(q).startsWith("$")
-	for (const set of filesets ?? []) {
-		const id = set.id.toLowerCase()
-		if (head && !id.includes(head) && !q.includes(id) && !typingFileset) continue
-		rows.push({
-			id: set.id,
-			title: set.id,
-			kind: "fileset",
-			detail: `${set.count} file${set.count === 1 ? "" : "s"}`,
-			completion: completeFileset(text, set.id),
-		})
-	}
-	for (const op of getOperations()) {
-		if (op.hidden) continue
-		const names = [op.name, ...(op.aliases ?? [])]
-		const matchesName = !head || names.some((name) => name.toLowerCase().includes(head))
-		if (!matchesName && !op.signature.toLowerCase().includes(q)) continue
-		rows.push({
-			id: `op:${op.name}`,
-			title: op.name,
-			kind: "op",
-			detail: op.signature,
-			description: op.description,
-			completion: q.includes(" ") ? text.replace(/^\S+/, op.name) : `${op.name} `,
-		})
-	}
-	const last = lastToken(q)
-	const token = lastToken(text)
-	if (token && !token.startsWith("$")) {
-		const at = token.lastIndexOf("/")
-		const dirPart = at >= 0 ? token.slice(0, at + 1) : ""
-		const prefix = (at >= 0 ? token.slice(at + 1) : token).toLowerCase()
-		for (const entry of context.entries ?? []) {
-			if (!entry.name.toLowerCase().startsWith(prefix)) continue
-			const name = entry.isDir ? `${entry.name}/` : entry.name
-			rows.push({
-				id: `path:${entry.path}`,
-				title: name,
-				kind: "path",
-				detail: entry.isDir ? "dir" : humanSize(entry.size),
-				completion: replaceLastToken(text, `${dirPart}${name}`),
-			})
-		}
-	}
-	return rows
-}
-
-// Function: lastToken
-// The last whitespace-separated token, case preserved.
-function lastToken(text) {
-	const match = /(\S+)\s*$/.exec(`${text ?? ""}`)
-	return match ? match[1] : ""
-}
-
-// Function: completionToken
-// For a query whose last token contains "/", the directory part to read and
-// the name prefix being completed; null when the token is not a path.
-function completionToken(query) {
-	const token = lastToken(query)
-	if (!token || token.startsWith("$")) return null
-	const at = token.lastIndexOf("/")
-	if (at < 0) return null
-	return { dir: token.slice(0, at) || "/", prefix: token.slice(at + 1) }
-}
-
-// Function: replaceLastToken
-// Replaces the (possibly empty) last whitespace-separated token.
-function replaceLastToken(text, replacement) {
-	const match = /(\S*)\s*$/.exec(text)
-	return `${text.slice(0, match.index)}${replacement}`
-}
-
-// Function: completeFileset
-// Replaces the `$…` token being typed, or appends the fileset.
-function completeFileset(text, id) {
-	if (/\$\w*$/.test(text.trimEnd())) return replaceLastToken(text, id)
-	return `${text} ${id}`.trim()
-}
-
-export { completionToken, parseLine, runLine, scriptItems, tokenize }
+export { parseLine, runLine, tokenize }
 
 // EOF

package/src/js/tcmd/core/selection.js

@@ -26,6 +26,14 @@ function currentEntry(entries, cursor) {
 	return entries[cursor]
 }
 
+// Function: indexOfPath
+// The index of the entry whose path is `path`, or -1. Navigations that must
+// land on a known element use it: the directory `up` stepped out of, the
+// current directory in a mirror's listing.
+function indexOfPath(entries, path) {
+	return entries.findIndex((entry) => entry.path === path)
+}
+
 // Function: toggleMark
 // Returns a new Set with `path` toggled in `marks`.
 function toggleMark(marks, path) {
@@ -38,6 +46,6 @@ function toggleMark(marks, path) {
 	return next
 }
 
-export { clampCursor, currentEntry, moveCursor, toggleMark }
+export { clampCursor, currentEntry, indexOfPath, moveCursor, toggleMark }
 
 // EOF