@ssebastien/tcmd 0.1.3 → 0.1.7

package/src/js/tcmd/core/panel.js

@@ -4,90 +4,170 @@
 // Created: 2026-10-09
 
 // Module: tcmd/core/panel
-// The command panel (Commando): a structured view over the operation registry.
-// It lists the operations alphabetically — ranked by match importance once a
-// query filters them (see `filterPanelOperations`) — and, for the selected
-// one, its arguments bound from
-// the live context — a selection argument shows the SRC/DST pane's marked paths
-// (falling back to the cursor entry) and lets the user toggle individual items;
-// a destination argument resolves to the DST pane's directory; textual
-// arguments (a name, a buffer label, a shell command) are typed in place.
+// The command panel (Commando): the one entry point for the CLI operations
+// (`copy`, `move`, `mkdir`, `new`, `chmod`, `hardlink`, `symlink`, `delete`,
+// `run` — the `core/operations` registry). They are grouped by purpose
+// (Command, File, Info, Create, Edit, Delete), using each operation's own
+// `group` metadata, and alphabetized within each group (see
+// `filterPanelEntries`). The workspace-view toggle and Quit are listed
+// alongside the CLI operations; other TinyCmd actions keep their keys.
+//
+// For the selected operation, the panel binds its arguments from the live
+// context — a selection argument shows the SRC/DST pane's marked paths (falling
+// back to the cursor entry) and lets the user toggle individual items; a
+// destination argument resolves to the DST pane's directory; textual arguments
+// (a name, a buffer label, a shell command) are typed in place. `chmod` binds
+// its MODE to the permission grid from `core/permissions`.
 //
 // The selection the user tweaks is *transient*: it lives in the draft bindings
 // (`session.panelDraft`), never in the real pane marks. When the draft runs,
 // each selection argument is encoded as a self-contained `$paths:[…]` token, so
-// the resolved paths survive an async confirm (see `expandArg`). The same draft
-// assembles the command line the panel previews (`panelCommand`), so the user
-// sees how the current selection maps to the operation before running it.
+// the resolved paths survive an async confirm (see `expandArg`). The draft can
+// also be rendered as a shell-quoted command (`panelCommand`), while the panel
+// itself presents the arguments and an explicit Run action.
 // Everything here is pure: the caller owns the cells; the panel commands in
-// `core/commands` assemble and run.
+// `core/commands` assemble and run. Picker path resolution and row shaping live
+// in `core/picker`.
 
-import { hasMatch, score } from "../vendor/fzy.js"
-import { PANE_BUFFERS, PANE_LABELS } from "./pane.js"
+import { hasMatch } from "../vendor/fzy.js"
+import { currentPaneId, PANE_BUFFERS, PANE_LABELS } from "./pane.js"
 import { basename, parent } from "./path.js"
-import { getOperations, pathToken } from "./operations.js"
+import { getOperations, pathToken, shellQuote } from "./operations.js"
+import { PERMISSION_BITS, PERMISSION_CLASSES, permissionItems, permissionOctal, permissionText } from "./permissions.js"
 
 // Constant: PANEL_FOCUS
-// The two columns the panel's focus ring moves through: "ops" (the operation
-// list, where typing filters) and "args" (an argument row, where Space toggles
-// and a textual argument owns the keyboard).
+// The two regions the panel's focus ring moves through: "ops" (the filter and
+// the command list on the left) and "args" (an argument row or item in the
+// right pane, where a textual argument owns the keyboard and Space toggles a
+// selection item).
 const PANEL_FOCUS = { OPS: "ops", ARGS: "args" }
+const PANEL_GROUPS = ["Command", "File", "Info", "Create", "Edit", "Delete"]
 
-// Function: panelOperations
-// The operations the panel lists: every visible registry entry that carries a
-// structured `args` signature (the ones that take arguments).
-function panelOperations() {
-	return getOperations().filter((op) => !op.hidden && Array.isArray(op.args))
+// Function: panelEntries
+// The entries the panel lists: the categorized CLI operations (each carries its
+// own `group`), the workspace-view toggle (named `view` like File's preview
+// operation, but in the Command group) and Quit.
+function panelEntries() {
+	const entries = getOperations()
+		.filter((op) => !op.hidden && op.group)
+		.map((op) => ({
+			id: `op:${op.name}`,
+			name: op.name,
+			group: op.group,
+			risk: op.risk ?? null,
+			matchNames: [op.name, ...(op.aliases ?? [])],
+			op,
+		}))
+	entries.push({
+		id: "command:view",
+		name: "view",
+		group: "Command",
+		risk: null,
+		matchNames: ["view"],
+		commandId: "view.toggleMode",
+		// A no-argument command still shows where it acts.
+		showPath: true,
+	})
+	entries.push({
+		id: "command:reload",
+		name: "reload",
+		group: "Command",
+		risk: null,
+		matchNames: ["reload", "refresh"],
+		commandId: "pane.reload",
+		// A no-argument command still shows where it acts.
+		showPath: true,
+	})
+	entries.push({
+		id: "command:quit",
+		name: "quit",
+		group: "Command",
+		risk: null,
+		matchNames: ["quit", "q"],
+		commandId: "app.quit",
+	})
+	return entries
 }
 
-// Function: compareOperations
-// Alphabetical order by name, the panel's default ordering.
-function compareOperations(a, b) {
-	return `${a?.name ?? ""}`.localeCompare(`${b?.name ?? ""}`)
+// Function: compareEntries
+// The panel's fixed category order, then alphabetical command order.
+function compareEntries(a, b) {
+	const groupA = PANEL_GROUPS.indexOf(`${a?.group ?? "File"}`)
+	const groupB = PANEL_GROUPS.indexOf(`${b?.group ?? "File"}`)
+	const rankA = groupA < 0 ? PANEL_GROUPS.length : groupA
+	const rankB = groupB < 0 ? PANEL_GROUPS.length : groupB
+	return rankA - rankB || `${a?.name ?? ""}`.localeCompare(`${b?.name ?? ""}`)
+}
+
+// Function: filterPanelEntries
+// Narrows the entry list by command name or alias and keeps the fixed category
+// order and alphabetical order within each group.
+function filterPanelEntries(entries, query) {
+	const list = entries ?? []
+	const q = `${query ?? ""}`.trim().toLowerCase()
+	if (!q) return [...list].sort(compareEntries)
+	return list
+		.filter((entry) => (entry.matchNames ?? []).some((name) => hasMatch(q, `${name}`.toLowerCase())))
+		.sort(compareEntries)
 }
 
-// Function: operationScore
-// The match importance of an operation for a query: the best fzy score across
-// its name and aliases, or `-Infinity` when neither matches (only the
-// signature does). Signature hits stay listable but rank below any name
-// match.
-function operationScore(op, query) {
-	let best = -Infinity
-	for (const name of [op.name, ...(op.aliases ?? [])]) {
-		if (hasMatch(query, name)) best = Math.max(best, score(query, name))
+// Function: panelEntryRows
+// Projects filtered entries into the command-list column: a group heading and
+// one name-only `op` row per entry, tagged with its index in the *entries* list
+// (what the cursor `panelOpIndex` addresses).
+function panelEntryRows(entries) {
+	const rows = []
+	let previousGroup = null
+	for (let index = 0; index < (entries ?? []).length; index++) {
+		const entry = entries[index]
+		const group = entry.group ?? "File"
+		if (group !== previousGroup) {
+			rows.push({ type: "group", key: `group:${group.toLowerCase()}`, name: group, group })
+			previousGroup = group
+		}
+		rows.push({
+			type: "op",
+			key: entry.id,
+			entryIndex: index,
+			name: entry.name,
+			group,
+			risk: entry.risk,
+		})
 	}
-	return best
+	return rows
 }
 
-// Function: filterPanelOperations
-// Narrows the operation list by a typed query and orders it: no query lists
-// every operation alphabetically; a query ranks the matches by importance
-// (the fzy score of the best name/alias match, so `open` outranks `copy` for
-// `op`), ties broken alphabetically. A query that only matches an operation's
-// signature (`buf` -> `sel [+|-][BUF] PATH...`) keeps it listable, at the
-// bottom.
-function filterPanelOperations(operations, query) {
-	const list = operations ?? []
-	const q = `${query ?? ""}`.trim().toLowerCase()
-	if (!q) return [...list].sort(compareOperations)
-	const ranked = []
-	for (const op of list) {
-		const rank = operationScore(op, q)
-		const signatureMatch = `${op.signature ?? ""}`.toLowerCase().includes(q)
-		if (rank === -Infinity && !signatureMatch) continue
-		ranked.push({ op, score: rank })
+// Function: explorerColumnId
+// The column an explorer argument draws from: the *focused* one, so focusing
+// the parent mirror selects from its own listing — the current directory, a
+// directory — and focusing the preview selects from the directory it mirrors.
+// A focused column without a listing (the inspector over a file) falls back to
+// the pane that owns the current directory, matching `core/commands#pane`.
+function explorerColumnId(session) {
+	const active = session.active?.value
+	if (active === "parent") return active
+	if (
+		active === "preview" &&
+		session.showPreview?.value &&
+		session.previewEntry?.value?.isDir &&
+		!session.preview?.value
+	) {
+		return active
 	}
-	ranked.sort((a, b) => (a.score !== b.score ? b.score - a.score : compareOperations(a.op, b.op)))
-	return ranked.map((match) => match.op)
+	return currentPaneId(session)
 }
 
 // Function: resolvePaneId
-// Maps an argument role to a pane id: "source" -> SRC (left), "dest" -> DST
-// (right), anything else -> the active pane.
+// Maps an argument role to a pane id: "source" -> the working pane (SRC in
+// commander; in explorer the focused column, which may be either side of the
+// chain), "dest" -> DST (right), anything else -> the pane holding the current
+// directory (the focused column in explorer, never an auxiliary column with no
+// listing, so operations run against what the cursor shows).
 function resolvePaneId(session, role) {
-	if (role === "source") return "left"
 	if (role === "dest") return "right"
-	return session.active.value
+	if (session.viewMode?.value === "explorer") return explorerColumnId(session)
+	if (role === "source") return "left"
+	return currentPaneId(session)
 }
 
 // Function: paneSelectionPaths
@@ -131,12 +211,16 @@ function bindArg(session, arg, index) {
 	const role = arg.role ?? "active"
 	const common = {
 		index,
+		// Display order in the argument pane; the argv order stays the
+		// operation's own (see `panelRowList` and `argTokens`).
+		panelOrder: arg.panelOrder ?? index,
 		name: arg.name,
 		kind: arg.kind,
 		role,
 		optional: arg.optional === true,
 		variadic: arg.variadic === true,
-		textual: arg.kind === "literal" || arg.kind === "raw" || arg.kind === "buffer",
+		textual:
+			arg.kind === "literal" || arg.kind === "raw" || arg.kind === "buffer" || arg.kind === "path",
 	}
 	if (arg.kind === "selection") {
 		const paneId = resolvePaneId(session, role)
@@ -145,26 +229,57 @@ function bindArg(session, arg, index) {
 		return {
 			...common,
 			paneId,
+			// A variadic selection accepts many marked paths (checkboxes); a
+			// single-path argument accepts one (a radio list).
+			multi: arg.variadic === true,
 			items: paneSelectionPaths(pane).map((path) => itemFor(entries, path)),
 			value: "",
 		}
 	}
-	if (arg.kind === "dest") {
-		const pane = session.panes.right
-		const path = pane?.path?.value ?? ""
-		// The destination is editable in place, like a literal (no toggles).
-		return { ...common, paneId: "right", textual: true, items: [], value: path }
+	if (arg.kind === "permissions") {
+		// Seed the checkboxes from the first selected path's current mode, so
+		// opening chmod starts on the file's real permissions rather than a
+		// generic 644. A path outside the listing falls back by kind.
+		const pane = session.panes[resolvePaneId(session, role)]
+		const entries = entryIndex(pane)
+		const path = paneSelectionPaths(pane)[0]
+		const entry = path ? entries.get(path) : null
+		const mode = Number.isInteger(entry?.mode)
+			? entry.mode & 0o777
+			: entry?.isDir
+				? 0o755
+				: 0o644
+		return { ...common, multi: true, items: permissionItems(mode) }
+	}
+	if (arg.kind === "dest" || arg.kind === "path") {
+		// A destination or a path argument is typeable in place, like a
+		// literal, and additionally browsable through the panel's file picker
+		// (`picker: true`, opened with `panel.browse`). In commander mode the
+		// DST pane is the natural destination, so a directory argument
+		// pre-fills from it; explorer mode has no destination pane, so it opens
+		// empty for the picker (or the user) to fill.
+		const mode = arg.kind === "dest" ? "dir" : arg.mode ?? "any"
+		const commander = (session.viewMode?.value ?? "commander") !== "explorer"
+		const value =
+			arg.prefill === "current"
+				? (session.activePath?.value ?? "")
+				: mode === "dir" && commander
+					? (session.panes?.right?.path?.value ?? "")
+					: ""
+		return { ...common, textual: true, picker: true, mode, items: [], value }
 	}
 	if (arg.kind === "buffer") {
-		return { ...common, items: [], value: `+${PANE_BUFFERS[session.active.value] ?? "A"}` }
+		const label = PANE_BUFFERS[session.currentId?.value ?? session.active.value] ?? "A"
+		return { ...common, items: [], value: `+${label}` }
 	}
 	return { ...common, items: [], value: "" }
 }
 
 // Function: bindArgs
-// Binds every argument of `op` to the live context.
-function bindArgs(session, op) {
-	return (op?.args ?? []).map((arg, index) => bindArg(session, arg, index))
+// Binds every argument of the selected entry to the live context. Every
+// operation carries an `args` signature.
+function bindArgs(session, entry) {
+	return (entry?.op?.args ?? []).map((arg, index) => bindArg(session, arg, index))
 }
 
 // Function: selectedPaths
@@ -184,6 +299,7 @@ function argTokens(bindings) {
 			const paths = selectedPaths(binding)
 			return paths.length ? pathToken(paths) : ""
 		}
+		if (binding.kind === "permissions") return permissionOctal(binding)
 		if (binding.kind === "dest") return binding.value ?? ""
 		return `${binding.value ?? ""}`.trim()
 	})
@@ -200,32 +316,29 @@ function argvFor(bindings) {
 	return args
 }
 
-// Function: missingArg
-// The name of the first argument that is not runnable: a required argument left
-// blank, an optional one before a filled one (a positional gap would shift the
-// following tokens), or a selection with nothing selected. Returns null when the
-// argv is runnable.
-function missingArg(bindings) {
+// Function: missingBinding
+// The first binding that is not runnable: a required argument left blank, an
+// optional one before a filled one (a positional gap would shift the following
+// tokens), or a selection with nothing selected. Returns null when the argv is
+// runnable. The panel uses it both to flag an unrunnable draft and to focus the
+// next thing to fill when Enter lands on an incomplete command.
+function missingBinding(bindings) {
 	const list = bindings ?? []
 	const args = argTokens(list)
 	for (let i = 0; i < args.length - 1; i++) {
-		if (args[i] === "") return list[i].name
+		if (args[i] === "") return list[i]
 	}
 	// A trailing required argument must still be filled.
 	const trailing = list[list.length - 1]
-	if (trailing && args[args.length - 1] === "" && trailing.optional !== true) return trailing.name
+	if (trailing && args[args.length - 1] === "" && trailing.optional !== true) return trailing
 	return null
 }
 
-// Function: shellQuote
-// Quotes a token for display as it would appear in a shell: bare when it is
-// already safe (`/home/a`), single-quoted when it contains spaces or shell
-// metacharacters (`'my notes.txt'`). Only the last path segment matters in
-// practice, but quoting the whole token keeps the preview copy-pasteable.
-function shellQuote(token) {
-	const text = `${token ?? ""}`
-	if (text === "") return "''"
-	return /^[A-Za-z0-9_@%+=:,.\/-]+$/.test(text) ? text : `'${text.replace(/'/g, `'\\''`)}'`
+// Function: missingArg
+// The name of the first argument that is not runnable (see `missingBinding`),
+// or null when the argv is runnable.
+function missingArg(bindings) {
+	return missingBinding(bindings)?.name ?? null
 }
 
 // Function: panelCommand
@@ -244,6 +357,10 @@ function panelCommand(bindings) {
 			else if (binding.optional !== true) parts.push(`«${binding.name}»`)
 			continue
 		}
+		if (binding.kind === "permissions") {
+			parts.push(permissionOctal(binding))
+			continue
+		}
 		const value = `${binding.value ?? ""}`.trim()
 		if (value) parts.push(shellQuote(value))
 		else if (binding.optional !== true) parts.push(`«${binding.name}»`)
@@ -269,41 +386,94 @@ function panelSummary(binding) {
 		const count = selectedPaths(binding).length
 		return `${pane} · ${count} selected`
 	}
-	if (binding.kind === "dest") return binding.value || "(none)"
+	if (binding.kind === "permissions") return permissionText(binding)
+	if (binding.kind === "dest" || binding.kind === "path") return binding.value || "(none)"
 	if (binding.kind === "buffer") return binding.value || "(active)"
 	return binding.value ? binding.value : "(empty)"
 }
 
 // Function: panelRowList
-// Flattens the draft into the rows the panel's argument column renders: one
-// header row per argument, followed by one item row per item of a
-// selection/destination argument (so individual paths can be toggled). Row
-// focus is assigned by the view (comparing the row index to the cursor), the
-// same way list rows are; this stays pure and index-stable.
+// Flattens the draft into the rows the panel's right-hand argument pane
+// renders: one header row per argument (its label and value/summary),
+// followed by one item row per selected path of a selection argument (so
+// individual paths can be toggled). A variadic selection shows checkboxes
+// (`[x]`/`[ ]`); a single-path one shows radios (`(•)`/`( )`). Row focus is
+// assigned by the view (comparing the row index to the cursor), the same way
+// list rows are; this stays pure and index-stable.
 function panelRowList(bindings) {
 	const rows = []
-	for (const binding of bindings ?? []) {
+	// The pane may show arguments in a different order from the argv (PATH
+	// before MODE/OWNER); the binding `index` still keys the draft.
+	const ordered = [...(bindings ?? [])].sort(
+		(a, b) => (a.panelOrder ?? a.index) - (b.panelOrder ?? b.index),
+	)
+	for (const binding of ordered) {
+		const multi = binding.multi === true
+		const items = binding.items ?? []
+		// A selection that resolves to a single path is not a list: it renders
+		// as a pre-filled, read-only path (no checkbox/radio to pick from).
+		const single = items.length === 1
 		rows.push({
 			type: "arg",
 			key: `arg:${binding.index}`,
+			rowIndex: rows.length,
 			argIndex: binding.index,
 			itemIndex: -1,
 			name: binding.name,
-			summary: panelSummary(binding),
+			summary: single ? items[0].path : panelSummary(binding),
 			kind: binding.kind,
 			role: binding.role,
 			optional: binding.optional,
 			variadic: binding.variadic,
 			textual: binding.textual,
+			editable: binding.textual === true,
+			picker: binding.picker === true,
+			mode: binding.mode ?? null,
+			multi,
+			readonly: single,
 			value: binding.value,
-			count: (binding.items ?? []).length,
+			count: items.length,
 		})
-		for (let i = 0; i < (binding.items ?? []).length; i++) {
-			const item = binding.items[i]
+		if (single) continue
+		// A permission argument renders as one row per class (u/g/o) with its
+		// three bits as clickable cells, rather than nine checkbox rows. The
+		// bit cursor (`panelPermBit`) selects the cell Space toggles.
+		if (binding.kind === "permissions") {
+			for (let c = 0; c < PERMISSION_CLASSES.length; c++) {
+				const permissionClass = PERMISSION_CLASSES[c]
+				const rowIndex = rows.length
+				const bits = PERMISSION_BITS.map((bit, i) => {
+					const itemIndex = c * PERMISSION_BITS.length + i
+					return {
+						id: bit.id,
+						selected: items[itemIndex]?.selected === true,
+						itemIndex,
+					}
+				})
+				rows.push({
+					type: "perm",
+					key: `perm:${binding.index}:${permissionClass.id}`,
+					rowIndex,
+					argIndex: binding.index,
+					classId: permissionClass.id,
+					label: permissionClass.label,
+					bits,
+					// Click payloads: arg index, item index, row index.
+					keyR: `${binding.index}:${bits[0].itemIndex}:${rowIndex}`,
+					keyW: `${binding.index}:${bits[1].itemIndex}:${rowIndex}`,
+					keyX: `${binding.index}:${bits[2].itemIndex}:${rowIndex}`,
+				})
+			}
+			continue
+		}
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i]
 			const selected = item.selected
+			const marker = multi ? (selected ? "[x]" : "[ ]") : selected ? "(•)" : "( )"
 			rows.push({
 				type: "item",
 				key: `item:${binding.index}:${item.path}`,
+				rowIndex: rows.length,
 				argIndex: binding.index,
 				itemIndex: i,
 				name: item.name,
@@ -311,7 +481,8 @@ function panelRowList(bindings) {
 				parent: item.parent ?? "",
 				isDir: item.isDir,
 				selected,
-				marker: selected ? "[x]" : "[ ]",
+				multi,
+				marker,
 			})
 		}
 	}
@@ -333,12 +504,13 @@ function isTextualRow(row) {
 
 // Function: withToggledItem
 // Returns a new draft with item `itemIndex` of argument `argIndex` toggled,
-// leaving the other bindings untouched.
-function withToggledItem(draft, argIndex, itemIndex) {
+// leaving the other bindings untouched. A single-path argument (`multi` false)
+// is a radio list: choosing one selects it alone.
+function withToggledItem(draft, argIndex, itemIndex, multi = true) {
 	return (draft ?? []).map((binding) => {
 		if (binding.index !== argIndex) return binding
 		const items = (binding.items ?? []).map((item, i) =>
-			i === itemIndex ? { ...item, selected: !item.selected } : item,
+			multi ? (i === itemIndex ? { ...item, selected: !item.selected } : item) : { ...item, selected: i === itemIndex },
 		)
 		return { ...binding, items }
 	})
@@ -364,14 +536,18 @@ export { decodePathToken, pathToken } from "./operations.js"
 
 export {
 	PANEL_FOCUS,
+	PANEL_GROUPS,
 	argvFor,
+	bindArg,
 	bindArgs,
 	bindingAt,
-	filterPanelOperations,
+	filterPanelEntries,
 	isTextualRow,
 	missingArg,
+	missingBinding,
 	panelCommand,
-	panelOperations,
+	panelEntries,
+	panelEntryRows,
 	panelRowList,
 	panelRunnable,
 	panelSummary,

package/src/js/tcmd/core/path.js

@@ -37,9 +37,11 @@ function split(p) {
 
 // Function: extname
 // Lowercased extension of the last segment, without the dot; null when the
-// name has no extension (or is a dotfile).
+// name has no extension (or is a dotfile). A bare filename (no separator), the
+// common case when building a listing, skips the `basename` split.
 function extname(p) {
-	const name = basename(p)
+	const text = `${p ?? ""}`
+	const name = text.indexOf(SEP) < 0 ? text : basename(text)
 	const at = name.lastIndexOf(".")
 	return at > 0 ? name.slice(at + 1).toLowerCase() : null
 }
@@ -52,6 +54,31 @@ function prefix(p, count) {
 	return SEP + parts.slice(0, Math.max(0, count)).join(SEP)
 }
 
-export { SEP, basename, extname, join, normalize, parent, prefix, split }
+// Function: relative
+// Expresses `target` relative to the absolute directory `base`, using `..`
+// segments when it sits outside: `relative("/a", "/a/b/c")` is `"b/c"` and
+// `relative("/a/b", "/a/c")` is `"../c"`. Equal paths collapse to `"."`. A
+// non-absolute input comes back unchanged, since there is nothing meaningful
+// to relativize against.
+function relative(base, target) {
+	const from = `${base ?? ""}`
+	const to = `${target ?? ""}`
+	if (!from.startsWith(SEP) || !to.startsWith(SEP)) return to
+	const baseParts = split(from)
+	const targetParts = split(to)
+	let common = 0
+	while (
+		common < baseParts.length &&
+		common < targetParts.length &&
+		baseParts[common] === targetParts[common]
+	) {
+		common += 1
+	}
+	const up = Array.from({ length: baseParts.length - common }, () => "..")
+	const down = targetParts.slice(common)
+	return [...up, ...down].join(SEP) || "."
+}
+
+export { SEP, basename, extname, join, normalize, parent, prefix, relative, split }
 
 // EOF