feat: command macro support

- macro for target filetype (issue: #114)

Author: Robitx

lua/gp/init.lua

@@ -6,6 +6,9 @@
 --------------------------------------------------------------------------------
 local config = require("gp.config")
 
+local uv = vim.uv or vim.loop
+table.unpack = table.unpack or unpack -- 5.1 compatibility
+
 local M = {
 	_Name = "Gp", -- plugin name
 	_state = {}, -- table of state variables
@@ -24,6 +27,7 @@ local M = {
 	tasker = require("gp.tasker"), -- tasker module
 	vault = require("gp.vault"), -- handles secrets
 	whisper = require("gp.whisper"), -- whisper module
+	macro = require("gp.macro"), -- builder for macro completion
 }
 
 --------------------------------------------------------------------------------
@@ -189,12 +193,41 @@ M.setup = function(opts)
 		end)
 	end
 
+	M.logger.debug("hook setup done")
+
+	local ft_completion = M.macro.build_completion({
+		require("gp.macros.target_filetype"),
+	}, {})
+
+	M.logger.debug("ft_completion done")
+
+	local do_completion = M.macro.build_completion({
+		require("gp.macros.target"),
+		require("gp.macros.target_filetype"),
+		require("gp.macros.target_filename"),
+	}, {})
+
+	M.logger.debug("do_completion done")
+
+	M.command_parser = M.macro.build_parser({
+		require("gp.macros.target"),
+		require("gp.macros.target_filetype"),
+		require("gp.macros.target_filename"),
+	})
+
+	M.logger.debug("command_parser done")
+
 	local completions = {
 		ChatNew = { "popup", "split", "vsplit", "tabnew" },
 		ChatPaste = { "popup", "split", "vsplit", "tabnew" },
 		ChatToggle = { "popup", "split", "vsplit", "tabnew" },
 		Context = { "popup", "split", "vsplit", "tabnew" },
 		Agent = agent_completion,
+		Do = do_completion,
+		Enew = ft_completion,
+		New = ft_completion,
+		Vnew = ft_completion,
+		Tabnew = ft_completion,
 	}
 
 	-- register default commands
@@ -1653,6 +1686,13 @@ M.Prompt = function(params, target, agent, template, prompt, whisper, callback)
 		local filetype = M.helpers.get_filetype(buf)
 		local filename = vim.api.nvim_buf_get_name(buf)
 
+		local state = {}
+		local response = M.command_parser(command, {}, state)
+		if response then
+			command = M.render.template(response.template, response.artifacts)
+			state = response.state
+		end
+
 		local sys_prompt = M.render.prompt_template(agent.system_prompt, command, selection, filetype, filename)
 		sys_prompt = sys_prompt or ""
 		table.insert(messages, { role = "system", content = sys_prompt })
@@ -1749,7 +1789,7 @@ M.Prompt = function(params, target, agent, template, prompt, whisper, callback)
 				end,
 			})
 
-			local ft = target.filetype or filetype
+			local ft = state.target_filetype or target.filetype or filetype
 			vim.api.nvim_set_option_value("filetype", ft, { buf = buf })
 
 			handler = M.dispatcher.create_handler(buf, win, 0, false, "", cursor)

lua/gp/macro.lua

@@ -0,0 +1,142 @@
+local logger = require("gp.logger")
+
+---@class gp.Macro_cmd_params
+---@field arg_lead string
+---@field cmd_line string
+---@field cursor_pos number
+---@field cropped_line string
+
+---@class gp.Macro_parser_result
+---@field template string
+---@field artifacts table<string, string>
+---@field state table
+
+--- gp.Macro Interface
+-- @field name string: Name of the macro.
+-- @field description string: Description of the macro.
+-- @field default string: Default value for the macro (optional).
+-- @field max_occurrences number: Maximum number of occurrences for the macro (optional).
+-- @field triggered function: Function that determines if the macro is triggered.
+-- @field completion function: Function that provides completion options.
+-- @field parser function: Function that processes the macro in the template.
+
+---@class gp.Macro
+---@field name string
+---@field description string
+---@field default? string
+---@field max_occurrences? number
+---@field triggered fun(params: gp.Macro_cmd_params, state: table): boolean
+---@field completion fun(params: gp.Macro_cmd_params, state: table): string[]
+---@field parser fun(params: gp.Macro_parser_result): gp.Macro_parser_result
+
+---@param value string # string to hash
+---@return string # returns hash of the string
+local fnv1a_hash = function(value)
+	---@type number
+	local hash = 2166136261
+	for i = 1, #value do
+		hash = vim.fn.xor(hash, string.byte(value, i))
+		hash = vim.fn["and"]((hash * 16777619), 0xFFFFFFFF)
+	end
+	return string.format("%08x", hash) -- return as an 8-character hex string
+end
+
+local M = {}
+
+---@param prefix string # prefix for the placeholder
+---@param value string # value to hash
+---@return string # returns placeholder
+M.generate_placeholder = function(prefix, value)
+	local hash_value = fnv1a_hash(value)
+	local placeholder = "{{" .. prefix .. "." .. hash_value .. "}}"
+	return placeholder
+end
+
+---@param macros gp.Macro[]
+---@return fun(template: string, artifacts: table, state: table): gp.Macro_parser_result
+M.build_parser = function(macros)
+	---@param template string
+	---@param artifacts table
+	---@param state table
+	---@return {template: string, artifacts: table, state: table}
+	local function parser(template, artifacts, state)
+		template = template or ""
+		---@type gp.Macro_parser_result
+		local result = {
+			template = " " .. template .. " ",
+			artifacts = artifacts or {},
+			state = state or {},
+		}
+		logger.debug("macro parser input: " .. vim.inspect(result))
+
+		for _, macro in pairs(macros) do
+			logger.debug("macro parser current macro: " .. vim.inspect(macro))
+			result = macro.parser(result)
+			logger.debug("macro parser result: " .. vim.inspect(result))
+		end
+		return result
+	end
+
+	return parser
+end
+
+---@param macros gp.Macro[]
+---@param state table
+---@return fun(arg_lead: string, cmd_line: string, cursor_pos: number): string[]
+M.build_completion = function(macros, state)
+	---@type table<string, gp.Macro>
+	local map = {}
+	for _, macro in pairs(macros) do
+		map[macro.name] = macro
+		state[macro.name .. "_default"] = macro.default
+	end
+
+	---@param arg_lead string
+	---@param cmd_line string
+	---@param cursor_pos number
+	---@return string[]
+	local function completion(arg_lead, cmd_line, cursor_pos)
+		local cropped_line = cmd_line:sub(1, cursor_pos)
+
+		---@type gp.Macro_cmd_params
+		local params = {
+			arg_lead = arg_lead,
+			cmd_line = cmd_line,
+			cursor_pos = cursor_pos,
+			cropped_line = cropped_line,
+		}
+
+		local suggestions = {}
+
+		logger.debug("macro completion input: " .. vim.inspect({
+			params = params,
+			state = state,
+		}))
+
+		---@type table<string, number>
+		local candidates = {}
+		local cand = nil
+		for c in cropped_line:gmatch("%s@(%S+)%s") do
+			candidates[c] = candidates[c] and candidates[c] + 1 or 1
+			cand = c
+		end
+		logger.debug("macro completion candidates: " .. vim.inspect(candidates))
+
+		if cand and map[cand] and map[cand].triggered(params, state) then
+			suggestions = map[cand].completion(params, state)
+		elseif cropped_line:match("%s$") or cropped_line:match("%s@%S*$") then
+			for _, c in pairs(macros) do
+				if not candidates[c.name] or candidates[c.name] < c.max_occurrences then
+					table.insert(suggestions, "@" .. c.name)
+				end
+			end
+		end
+
+		logger.debug("macro completion suggestions: " .. vim.inspect(suggestions))
+		return vim.deepcopy(suggestions)
+	end
+
+	return completion
+end
+
+return M

lua/gp/macros/target.lua

@@ -0,0 +1,47 @@
+local macro = require("gp.macro")
+
+local values = {
+	"rewrite",
+	"append",
+	"prepend",
+	"popup",
+	"enew",
+	"new",
+	"vnew",
+	"tabnew",
+}
+
+local M = {}
+
+---@type gp.Macro
+M = {
+	name = "target",
+	description = "handles target for commands",
+	default = "rewrite",
+	max_occurrences = 1,
+
+	triggered = function(params, state)
+		local cropped_line = params.cropped_line
+		return cropped_line:match("@target%s+%S*$")
+	end,
+
+	completion = function(params, state)
+		return values
+	end,
+
+	parser = function(result)
+		local template = result.template
+		local s, e, value = template:find("@target%s+(%S+)")
+		if not value then
+			return result
+		end
+
+		local placeholder = macro.generate_placeholder(M.name, value)
+		result.template = template:sub(1, s - 2) .. placeholder .. template:sub(e + 1)
+		result.state[M.name] = value
+		result.artifacts[placeholder] = ""
+		return result
+	end,
+}
+
+return M

lua/gp/macros/target_filename.lua

@@ -0,0 +1,44 @@
+local macro = require("gp.macro")
+
+local M = {}
+
+---@type gp.Macro
+M = {
+	name = "target_filename`",
+	description = "handles target buffer filename for commands",
+	default = nil,
+	max_occurrences = 1,
+
+	triggered = function(params, state)
+		local cropped_line = params.cropped_line
+		return cropped_line:match("@target_filename`[^`]*$")
+	end,
+
+	completion = function(params, state)
+		-- TODO state.root_dir ?
+		local files = vim.fn.glob("**", true, true)
+		-- local files = vim.fn.getcompletion("", "file")
+		files = vim.tbl_map(function(file)
+			return file .. " `"
+		end, files)
+		return files
+	end,
+
+	parser = function(result)
+		local template = result.template
+		local s, e, value = template:find("@target_filename`([^`]*)`")
+		if not value then
+			return result
+		end
+
+		value = value:match("^%s*(.-)%s*$")
+		local placeholder = macro.generate_placeholder(M.name, value)
+
+		result.template = template:sub(1, s - 2) .. placeholder .. template:sub(e + 1)
+		result.state[M.name] = value
+		result.artifacts[placeholder] = ""
+		return result
+	end,
+}
+
+return M

lua/gp/macros/target_filetype.lua

@@ -0,0 +1,38 @@
+local macro = require("gp.macro")
+
+local values = vim.fn.getcompletion("", "filetype")
+
+local M = {}
+
+---@type gp.Macro
+M = {
+	name = "target_filetype",
+	description = "handles target buffer filetype for commands like GpEnew",
+	default = "markdown",
+	max_occurrences = 1,
+
+	triggered = function(params, state)
+		local cropped_line = params.cropped_line
+		return cropped_line:match("@target_filetype%s+%S*$")
+	end,
+
+	completion = function(params, state)
+		return values
+	end,
+
+	parser = function(result)
+		local template = result.template
+		local s, e, value = template:find("@target_filetype%s+(%S+)")
+		if not value then
+			return result
+		end
+
+		local placeholder = macro.generate_placeholder(M.name, value)
+		result.template = template:sub(1, s - 2) .. placeholder .. template:sub(e + 1)
+		result.state[M.name] = value
+		result.artifacts[placeholder] = ""
+		return result
+	end,
+}
+
+return M