npm - gm-copilot-cli - Versions diffs - 2.0.524 → 2.0.525 - Mend

gm-copilot-cli 2.0.524 → 2.0.525

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.

Files changed (5) hide show

package/copilot-profile.md CHANGED Viewed

@@ -1,6 +1,6 @@
 ---
 name: gm
-version: 2.0.524
+version: 2.0.525
 description: State machine agent with hooks, skills, and automated git enforcement
 author: AnEntrypoint
 repository: https://github.com/AnEntrypoint/gm-copilot-cli

package/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Copilot CLI - gm plugin</title>
-  <link rel="stylesheet" href="https://unpkg.com/rippleui@1.12.1/dist/css/styles.css">
-  <script type="importmap">{"imports":{"webjsx":"https://cdn.jsdelivr.net/npm/webjsx@0.0.42/dist/index.js"}}</script>
+  <script src="https://cdn.tailwindcss.com"></script>
   <style>
     body{background:#0f172a;color:#e2e8f0;font-family:system-ui,sans-serif;margin:0}
     .gradient-hero{background:linear-gradient(135deg,#0f172a 0%,#1e1b4b 50%,#0f172a 100%)}
@@ -15,10 +15,486 @@
   </style>
 </head>
 <body>
-<script type="module">
-import { createElement as h, applyDiff } from "webjsx";
+<script>
+const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+const MATH_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const Fragment = (props) => {
+    return props.children
+        ? Array.isArray(props.children)
+            ? props.children
+            : [props.children]
+        : [];
+};
+/**
+ * Handles event listener updates for an element
+ */
+function updateEventListener(el, eventName, newHandler, oldHandler) {
+    if (oldHandler && oldHandler !== newHandler) {
+        el.removeEventListener(eventName, oldHandler);
+    }
+    if (newHandler && oldHandler !== newHandler) {
+        el.addEventListener(eventName, newHandler);
+        el.__webjsx_listeners = {
+            ...(el.__webjsx_listeners || {}),
+            [eventName]: newHandler,
+        };
+    }
+}
+/**
+ * Updates a single property or attribute on an element
+ */
+function updatePropOrAttr(el, key, value) {
+    if (el instanceof HTMLElement) {
+        if (key in el) {
+            // Fast path: property exists on HTMLElement
+            el[key] = value;
+            return;
+        }
+        if (typeof value === "string") {
+            el.setAttribute(key, value);
+            return;
+        }
+        // Fallback for non-string values on HTMLElement
+        el[key] = value;
+        return;
+    }
+    // SVG/Other namespace elements
+    const isSVG = el.namespaceURI === "http://www.w3.org/2000/svg";
+    if (isSVG) {
+        if (value != null) {
+            el.setAttribute(key, value.toString());
+        }
+        else {
+            el.removeAttribute(key);
+        }
+        return;
+    }
+    // Fallback for other element types
+    if (typeof value === "string") {
+        el.setAttribute(key, value);
+    }
+    else {
+        el[key] = value;
+    }
+}
+/**
+ * Handles suspension of rendering during updates
+ */
+function withRenderSuspension(el, callback) {
+    const isRenderingSuspended = !!el
+        .__webjsx_suspendRendering;
+    if (isRenderingSuspended) {
+        el.__webjsx_suspendRendering();
+    }
+    try {
+        return callback();
+    }
+    finally {
+        if (isRenderingSuspended) {
+            el.__webjsx_resumeRendering();
+        }
+    }
+}
+/**
+ * Core function to update attributes and properties on a DOM element
+ */
+function updateAttributesCore(el, newProps, oldProps = {}) {
+    // Handle new/updated props
+    for (const [key, value] of Object.entries(newProps)) {
+        if (key === "children" ||
+            key === "key" ||
+            key === "dangerouslySetInnerHTML")
+            continue;
+        if (key.startsWith("on") && typeof value === "function") {
+            const eventName = key.substring(2).toLowerCase();
+            updateEventListener(el, eventName, value, el.__webjsx_listeners?.[eventName]);
+        }
+        else if (value !== oldProps[key]) {
+            updatePropOrAttr(el, key, value);
+        }
+    }
+    // Handle dangerouslySetInnerHTML
+    if ("dangerouslySetInnerHTML" in newProps) {
+        const html = newProps.dangerouslySetInnerHTML.__html || "";
+        el.innerHTML = html;
+    }
+    else if ("dangerouslySetInnerHTML" in oldProps) {
+        el.innerHTML = "";
+    }
+    // If this is a fresh set (no oldProps), remove any attributes not in newProps
+    if (Object.keys(oldProps).length === 0) {
+        const currentAttrs = Array.from(el.attributes).map((attr) => attr.name);
+        for (const attr of currentAttrs) {
+            if (!(attr in newProps) && !attr.startsWith("on")) {
+                el.removeAttribute(attr);
+            }
+        }
+    }
+    // Remove old props/attributes
+    for (const key of Object.keys(oldProps)) {
+        if (!(key in newProps) &&
+            key !== "children" &&
+            key !== "key" &&
+            key !== "dangerouslySetInnerHTML") {
+            if (key.startsWith("on")) {
+                const eventName = key.substring(2).toLowerCase();
+                const existingListener = el.__webjsx_listeners?.[eventName];
+                if (existingListener) {
+                    el.removeEventListener(eventName, existingListener);
+                    delete el.__webjsx_listeners[eventName];
+                }
+            }
+            else if (key in el) {
+                el[key] = undefined;
+            }
+            else {
+                el.removeAttribute(key);
+            }
+        }
+    }
+    // Store current props for future updates
+    el.__webjsx_props = newProps;
+}
+/**
+ * Sets attributes and properties on a DOM element based on the provided props.
+ * If the property exists on the element, it sets it as a property.
+ * Otherwise, it sets it as an attribute or property based on the value type.
+ *
+ * @param el - The DOM element to update.
+ * @param props - The new properties to apply.
+ */
+function setAttributes(el, props) {
+    withRenderSuspension(el, () => {
+        updateAttributesCore(el, props);
+    });
+}
+/**
+ * Updates attributes and properties on a DOM element based on the new and old props.
+ *
+ * @param el - The DOM element to update.
+ * @param newProps - The new properties to apply.
+ * @param oldProps - The old properties to compare against.
+ */
+function updateAttributes(el, newProps, oldProps) {
+    withRenderSuspension(el, () => {
+        updateAttributesCore(el, newProps, oldProps);
+    });
+}
+function isFragment(type) {
+    return type === Fragment;
+}
+function createNode(vnode, parentNamespaceURI) {
+    if (typeof vnode === "string" ||
+        typeof vnode === "number" ||
+        typeof vnode === "boolean") {
+        return document.createTextNode(String(vnode));
+    }
+    else if (isFragment(vnode.type)) {
+        const fragment = document.createDocumentFragment();
+        if (vnode.props.children) {
+            const children = vnode.props.children;
+            children.forEach((child) => {
+                fragment.appendChild(createNode(child, undefined));
+            });
+        }
+        return fragment;
+    }
+    else {
+        const namespaceURI = vnode.props.xmlns !== undefined
+            ? vnode.props.xmlns
+            : vnode.type === "svg"
+                ? SVG_NAMESPACE
+                : parentNamespaceURI ?? undefined;
+        const el = vnode.props.is !== undefined
+            ? namespaceURI !== undefined
+                ? document.createElementNS(namespaceURI, vnode.type, {
+                    is: vnode.props.is,
+                })
+                : document.createElement(vnode.type, {
+                    is: vnode.props.is,
+                })
+            : namespaceURI !== undefined
+                ? document.createElementNS(namespaceURI, vnode.type)
+                : document.createElement(vnode.type);
+        if (vnode.props) {
+            setAttributes(el, vnode.props);
+        }
+        if (vnode.props.key != null) {
+            el.__webjsx_key = vnode.props.key;
+            el.setAttribute("data-key", String(vnode.props.key));
+        }
+        if (vnode.props.ref) {
+            assignRef(el, vnode.props.ref);
+        }
+        if (vnode.props.children && !vnode.props.dangerouslySetInnerHTML) {
+            const children = vnode.props.children;
+            children.forEach((child) => {
+                el.appendChild(createNode(child, namespaceURI));
+            });
+        }
+        return el;
+    }
+}
+/**
+ * Assigns a ref to a node.
+ * @param node The DOM node.
+ * @param ref The ref to assign.
+ */
+function assignRef(node, ref) {
+    const currentRef = node.__webjsx_assignedRef;
+    // Only assign the ref if it's different
+    if (currentRef !== ref) {
+        if (typeof ref === "function") {
+            ref(node);
+        }
+        else if (ref && typeof ref === "object") {
+            ref.current = node;
+        }
+        // Store the assigned ref
+        node.__webjsx_assignedRef = ref;
+    }
+}
+function createElement(type, props, ...children) {
+    const normalizedProps = props ? { ...props } : {};
+    const flatChildren = [];
+    const flatten = (child) => {
+        if (Array.isArray(child)) {
+            child.forEach(flatten);
+        }
+        else if (typeof child === "string" || typeof child === "number") {
+            flatChildren.push(child);
+        }
+        else if (child === null ||
+            child === undefined ||
+            typeof child === "boolean") {
+            // Ignore null or undefined children
+        }
+        else {
+            flatChildren.push(child);
+        }
+    };
+    children.forEach(flatten);
+    if (flatChildren.length > 0) {
+        // Only set children if dangerouslySetInnerHTML is not present
+        if (!normalizedProps.dangerouslySetInnerHTML) {
+            normalizedProps.children = flatChildren;
+        }
+        else {
+            console.warn("WebJSX: Ignoring children since dangerouslySetInnerHTML is set.");
+        }
+    }
+    return {
+        type,
+        props: normalizedProps,
+    };
+}
+/**
+ * Applies the differences between the new virtual node(s) and the existing DOM.
+ * @param parent The parent DOM node where the virtual nodes will be applied.
+ * @param newVirtualNode A single virtual node or an array of virtual nodes.
+ */
+function applyDiff(parent, newVirtualNode) {
+    const newVNodes = Array.isArray(newVirtualNode)
+        ? newVirtualNode
+        : [newVirtualNode];
+    diffChildren(parent, newVNodes);
+}
+/**
+ * Flattens the list of virtual nodes by replacing Fragments with their children.
+ * @param vnodes The array of virtual nodes to flatten.
+ * @returns A new array of virtual nodes with Fragments flattened.
+ */
+function flattenVNodes(vnodes) {
+    const flat = [];
+    const arrayVNodes = vnodes;
+    arrayVNodes.forEach((vnode) => {
+        if (isFragment(vnode)) {
+            const children = vnode.props.children ? vnode.props.children : [];
+            flat.push(...children);
+        }
+        else {
+            flat.push(vnode);
+        }
+    });
+    return flat;
+}
+/**
+ * Type guard to check if a VNode is a Fragment.
+ * @param vnode The virtual node to check.
+ * @returns True if vnode is a Fragment, false otherwise.
+ */
+function isFragment(vnode) {
+    return typeof vnode === "object" && vnode !== null && vnode.type === Fragment;
+}
+/**
+ * Diffs and updates the children of a DOM node based on the new virtual nodes.
+ * @param parent The parent DOM node whose children will be diffed.
+ * @param newVNodes An array of new virtual nodes.
+ */
+function diffChildren(parent, newVNodes) {
+    const flattenedVNodes = flattenVNodes(newVNodes);
+    const existingNodes = Array.from(parent.childNodes);
+    const keyedMap = new Map();
+    // Populate keyedMap with existing keyed nodes
+    existingNodes.forEach((node) => {
+        const key = node.__webjsx_key;
+        if (key != null) {
+            keyedMap.set(key, node);
+        }
+    });
+    const newKeys = flattenedVNodes
+        .filter(isVElementWithKey)
+        .map((vnode) => vnode.props.key);
+    existingNodes.forEach((node) => {
+        const key = node.__webjsx_key;
+        if (key != null && !newKeys.includes(key)) {
+            parent.removeChild(node);
+        }
+    });
+    flattenedVNodes.forEach((newVNode, i) => {
+        const newKey = isVElement(newVNode) ? newVNode.props.key : undefined;
+        let existingNode = null;
+        if (newKey != null) {
+            existingNode = keyedMap.get(newKey) || null;
+        }
+        if (!existingNode && newKey == null) {
+            existingNode = parent.childNodes[i] || null;
+        }
+        if (existingNode) {
+            if (existingNode !== parent.childNodes[i]) {
+                parent.insertBefore(existingNode, parent.childNodes[i] || null);
+            }
+            updateNode(existingNode, newVNode);
+        }
+        else {
+            const newDomNode = createNode(newVNode, getNamespaceURI(parent));
+            if (isVElement(newVNode) && newVNode.props.key != null) {
+                newDomNode.__webjsx_key = newVNode.props.key;
+                newDomNode.setAttribute("data-key", String(newVNode.props.key));
+            }
+            parent.insertBefore(newDomNode, parent.childNodes[i] || null);
+        }
+    });
+    const updatedChildNodes = Array.from(parent.childNodes);
+    const newUnkeyed = flattenedVNodes.filter((vnode) => !isVElementWithKey(vnode));
+    const existingUnkeyed = updatedChildNodes.filter((node) => !node.__webjsx_key);
+    if (newUnkeyed.length < existingUnkeyed.length) {
+        for (let i = newUnkeyed.length; i < existingUnkeyed.length; i++) {
+            parent.removeChild(existingUnkeyed[i]);
+        }
+    }
+}
+/**
+ * Updates a DOM node to match the new virtual node.
+ * @param domNode The existing DOM node to be updated.
+ * @param newVNode The new virtual node to apply.
+ */
+function updateNode(domNode, newVNode) {
+    if (typeof newVNode === "string" ||
+        typeof newVNode === "number" ||
+        typeof newVNode === "boolean") {
+        if (domNode.nodeType !== Node.TEXT_NODE ||
+            domNode.textContent !== String(newVNode)) {
+            const newTextNode = document.createTextNode(String(newVNode));
+            domNode.parentNode?.replaceChild(newTextNode, domNode);
+        }
+        return;
+    }
+    if (newVNode.type === Fragment) {
+        if (domNode instanceof DocumentFragment) {
+            diffChildren(domNode, newVNode.props.children ? newVNode.props.children : []);
+        }
+        else {
+            const fragment = document.createDocumentFragment();
+            const children = newVNode.props.children ? newVNode.props.children : [];
+            children.forEach((child) => {
+                fragment.appendChild(createNode(child, undefined));
+            });
+            domNode.parentNode?.replaceChild(fragment, domNode);
+        }
+        return;
+    }
+    if (domNode instanceof HTMLElement &&
+        domNode.tagName.toLowerCase() === newVNode.type.toLowerCase()) {
+        const oldProps = domNode.__webjsx_props || {};
+        const newProps = newVNode.props || {};
+        updateAttributes(domNode, newProps, oldProps);
+        if (isVElement(newVNode) && newVNode.props.key != null) {
+            domNode.__webjsx_key = newVNode.props.key;
+            domNode.setAttribute("data-key", String(newVNode.props.key));
+        }
+        else {
+            delete domNode.__webjsx_key;
+            domNode.removeAttribute("data-key");
+        }
+        if (newProps.ref) {
+            assignRef(domNode, newProps.ref);
+        }
+        if (!newProps.dangerouslySetInnerHTML && newProps.children != null) {
+            diffChildren(domNode, newProps.children);
+        }
+    }
+    else {
+        const newDomNode = createNode(newVNode, domNode.parentNode ? getNamespaceURI(domNode.parentNode) : undefined);
+        if (isVElement(newVNode) && newVNode.props.key != null) {
+            newDomNode.__webjsx_key = newVNode.props.key;
+            newDomNode.setAttribute("data-key", String(newVNode.props.key));
+        }
+        if (isVElement(newVNode) && newVNode.props.ref) {
+            assignRef(newDomNode, newVNode.props.ref);
+        }
+        domNode.parentNode?.replaceChild(newDomNode, domNode);
+    }
+}
+/**
+ * Assigns a ref to a node.
+ * @param node The DOM node.
+ * @param ref The ref to assign.
+ */
+function assignRef(node, ref) {
+    const currentRef = node.__webjsx_assignedRef;
+    // Only assign the ref if it's different
+    if (currentRef !== ref) {
+        if (typeof ref === "function") {
+            ref(node);
+        }
+        else if (ref && typeof ref === "object") {
+            ref.current = node;
+        }
+        // Store the assigned ref
+        node.__webjsx_assignedRef = ref;
+    }
+}
+/**
+ * Type guard to check if a VNode is a VElement.
+ * @param vnode The virtual node to check.
+ * @returns True if vnode is a VElement, false otherwise.
+ */
+function isVElement(vnode) {
+    return typeof vnode === "object" && vnode !== null && "props" in vnode;
+}
+/**
+ * Type guard to check if a VNode is a VElement with a key.
+ * @param vnode The virtual node to check.
+ * @returns True if vnode is a VElement with a key, false otherwise.
+ */
+function isVElementWithKey(vnode) {
+    return isVElement(vnode) && vnode.props.key != null;
+}
+function getNamespaceURI(node) {
+    return node instanceof Element && node.namespaceURI !== HTML_NAMESPACE
+        ? node.namespaceURI ?? undefined
+        : undefined;
+}
 const PLATFORM_NAME="Copilot CLI",PLATFORM_TYPE="CLI Tool",PLATFORM_TYPE_COLOR="#3b82f6";
-const DESCRIPTION="State machine agent with hooks, skills, and automated git enforcement",VERSION="2.0.524";
+const DESCRIPTION="State machine agent with hooks, skills, and automated git enforcement",VERSION="2.0.525";
 const GITHUB_URL="https://github.com/AnEntrypoint/gm-copilot-cli",BADGE_LABEL="copilot-cli";
 const FEATURES=[{"title":"State Machine","desc":"Immutable PLAN→EXECUTE→EMIT→VERIFY→COMPLETE phases with full mutable tracking"},{"title":"Semantic Search","desc":"Natural language codebase exploration via codesearch skill — no grep needed"},{"title":"Hooks","desc":"Pre-tool, session-start, prompt-submit, and stop hooks for full lifecycle control"},{"title":"Agents","desc":"gm, codesearch, and websearch agents pre-configured and ready to use"},{"title":"MCP Integration","desc":"Model Context Protocol server support built in"},{"title":"Auto-Recovery","desc":"Supervisor hierarchy ensures the system never crashes"}],INSTALL_STEPS=[{"desc":"Install via GitHub CLI","cmd":"gh extension install AnEntrypoint/gm-copilot-cli"},{"desc":"Restart your terminal — activates automatically"}];
 const CURRENT_PLATFORM="gm-copilot-cli";

package/manifest.yml CHANGED Viewed

@@ -1,5 +1,5 @@
 name: gm
-version: 2.0.524
+version: 2.0.525
 description: State machine agent with hooks, skills, and automated git enforcement
 author: AnEntrypoint

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "gm-copilot-cli",
-  "version": "2.0.524",
+  "version": "2.0.525",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/tools.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.524",
+  "version": "2.0.525",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "tools": [
     {