wave-code 0.2.1 → 0.5.0

package/src/commands/plugin/install.ts

@@ -3,11 +3,12 @@ import {
   ConfigurationService,
   PluginManager,
   PluginScopeManager,
+  Scope,
 } from "wave-agent-sdk";
 
 export async function installPluginCommand(argv: {
   plugin: string;
-  scope?: "user" | "project" | "local";
+  scope?: Scope;
 }) {
   const marketplaceService = new MarketplaceService();
   const workdir = process.cwd();

package/src/commands/plugin/list.ts

@@ -1,9 +1,23 @@
-import { MarketplaceService, ConfigurationService } from "wave-agent-sdk";
+import {
+  MarketplaceService,
+  ConfigurationService,
+  PluginScopeManager,
+  PluginManager,
+} from "wave-agent-sdk";
 
 export async function listPluginsCommand() {
-  const marketplaceService = new MarketplaceService();
   const configurationService = new ConfigurationService();
+  const marketplaceService = new MarketplaceService();
   const workdir = process.cwd();
+  const pluginManager = new PluginManager({
+    workdir,
+    configurationService,
+  });
+  const pluginScopeManager = new PluginScopeManager({
+    workdir,
+    configurationService,
+    pluginManager,
+  });
 
   try {
     const installedPlugins = await marketplaceService.getInstalledPlugins();
@@ -16,6 +30,7 @@ export async function listPluginsCommand() {
       marketplace: string;
       installed: boolean;
       version?: string;
+      scope?: string;
     }[] = [];
 
     for (const m of marketplaces) {
@@ -24,6 +39,7 @@ export async function listPluginsCommand() {
           marketplaceService.getMarketplacePath(m),
         );
         manifest.plugins.forEach((p) => {
+          const pluginId = `${p.name}@${m.name}`;
           const installed = installedPlugins.plugins.find(
             (ip) => ip.name === p.name && ip.marketplace === m.name,
           );
@@ -32,6 +48,7 @@ export async function listPluginsCommand() {
             marketplace: m.name,
             installed: !!installed,
             version: installed?.version,
+            scope: pluginScopeManager.findPluginScope(pluginId) || undefined,
           });
         });
       } catch {
@@ -52,7 +69,8 @@ export async function listPluginsCommand() {
             : "disabled"
           : "not installed";
         const versionStr = p.version ? ` v${p.version}` : "";
-        console.log(`- ${pluginId}${versionStr} [${status}]`);
+        const scopeStr = p.scope ? ` (${p.scope})` : "";
+        console.log(`- ${pluginId}${versionStr}${scopeStr} [${status}]`);
       });
     }
     process.exit(0);

package/src/commands/plugin/marketplace.ts

@@ -42,7 +42,10 @@ export async function listMarketplacesCommand() {
         } else {
           sourceInfo = source.url + (source.ref ? `#${source.ref}` : "");
         }
-        console.log(`- ${m.name}: ${sourceInfo} (${m.source.source})`);
+        const builtinLabel = m.isBuiltin ? " [builtin]" : "";
+        console.log(
+          `- ${m.name}${builtinLabel}: ${sourceInfo} (${m.source.source})`,
+        );
       });
     }
     process.exit(0);
@@ -53,6 +56,19 @@ export async function listMarketplacesCommand() {
   }
 }
 
+export async function removeMarketplaceCommand(argv: { name: string }) {
+  const service = new MarketplaceService();
+  try {
+    await service.removeMarketplace(argv.name);
+    console.log(`Successfully removed marketplace: ${argv.name}`);
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to remove marketplace: ${message}`);
+    process.exit(1);
+  }
+}
+
 export async function updateMarketplaceCommand(argv: { name?: string }) {
   const service = new MarketplaceService();
   try {

package/src/commands/plugin/uninstall.ts

@@ -0,0 +1,39 @@
+import {
+  MarketplaceService,
+  ConfigurationService,
+  PluginManager,
+  PluginScopeManager,
+} from "wave-agent-sdk";
+
+export async function uninstallPluginCommand(argv: { plugin: string }) {
+  const marketplaceService = new MarketplaceService();
+  const workdir = process.cwd();
+
+  try {
+    await marketplaceService.uninstallPlugin(argv.plugin, workdir);
+    console.log(`Successfully uninstalled plugin: ${argv.plugin}`);
+
+    const configurationService = new ConfigurationService();
+    const pluginManager = new PluginManager({ workdir });
+    const scopeManager = new PluginScopeManager({
+      workdir,
+      configurationService,
+      pluginManager,
+    });
+
+    try {
+      await scopeManager.removePluginFromAllScopes(argv.plugin);
+      console.log(`Cleaned up plugin configuration from all scopes`);
+    } catch (error) {
+      console.warn(
+        `Warning: Could not clean up all plugin configurations: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to uninstall plugin: ${message}`);
+    process.exit(1);
+  }
+}

package/src/commands/plugin/update.ts

@@ -0,0 +1,19 @@
+import { MarketplaceService } from "wave-agent-sdk";
+
+export async function updatePluginCommand(argv: { plugin: string }) {
+  const marketplaceService = new MarketplaceService();
+
+  try {
+    const updated = await marketplaceService.updatePlugin(argv.plugin);
+    console.log(
+      `Successfully updated plugin: ${updated.name} v${updated.version} from ${updated.marketplace}`,
+    );
+    console.log(`Cache path: ${updated.cachePath}`);
+
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to update plugin: ${message}`);
+    process.exit(1);
+  }
+}

package/src/components/ChatInterface.tsx

@@ -27,6 +27,7 @@ export const ChatInterface: React.FC = () => {
     confirmingTool,
     handleConfirmationDecision,
     handleConfirmationCancel,
+    rewindId,
   } = useChat();
 
   if (!sessionId) return null;
@@ -40,7 +41,7 @@ export const ChatInterface: React.FC = () => {
         isCompressing={isCompressing}
         latestTotalTokens={latestTotalTokens}
         isExpanded={isExpanded}
-        key={String(isExpanded) + sessionId}
+        key={String(isExpanded) + sessionId + rewindId}
       />
 
       {isConfirmationVisible && (

package/src/components/CommandSelector.tsx

@@ -4,9 +4,9 @@ import type { SlashCommand } from "wave-agent-sdk";
 
 const AVAILABLE_COMMANDS: SlashCommand[] = [
   {
-    id: "bashes",
-    name: "bashes",
-    description: "View and manage background bash shells",
+    id: "tasks",
+    name: "tasks",
+    description: "View and manage background tasks (shells and subagents)",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
   {
@@ -15,6 +15,13 @@ const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "View and manage MCP servers",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "rewind",
+    name: "rewind",
+    description:
+      "Revert conversation and file changes to a previous checkpoint",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
 ];
 
 export interface CommandSelectorProps {

package/src/components/Confirmation.tsx

@@ -65,6 +65,7 @@ export interface ConfirmationProps {
 interface ConfirmationState {
   selectedOption: "allow" | "auto" | "alternative";
   alternativeText: string;
+  alternativeCursorPosition: number;
   hasUserInput: boolean; // to hide placeholder
 }
 
@@ -81,6 +82,7 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
   const [state, setState] = useState<ConfirmationState>({
     selectedOption: "allow",
     alternativeText: "",
+    alternativeCursorPosition: 0,
     hasUserInput: false,
   });
 
@@ -92,6 +94,7 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
   >(new Set());
   const [userAnswers, setUserAnswers] = useState<Record<string, string>>({});
   const [otherText, setOtherText] = useState("");
+  const [otherCursorPosition, setOtherCursorPosition] = useState(0);
 
   const questions =
     (toolInput as unknown as AskUserQuestionInput)?.questions || [];
@@ -159,6 +162,7 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
           setSelectedOptionIndex(0);
           setSelectedOptionIndices(new Set());
           setOtherText("");
+          setOtherCursorPosition(0);
         } else {
           // All questions answered
           onDecision({
@@ -207,10 +211,38 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
       }
 
       if (isOtherFocused) {
+        if (key.leftArrow) {
+          setOtherCursorPosition((prev) => Math.max(0, prev - 1));
+          return;
+        }
+        if (key.rightArrow) {
+          setOtherCursorPosition((prev) =>
+            Math.min(otherText.length, prev + 1),
+          );
+          return;
+        }
         if (key.backspace || key.delete) {
-          setOtherText((prev) => prev.slice(0, -1));
-        } else if (input && !key.ctrl && !key.meta) {
-          setOtherText((prev) => prev + input);
+          if (otherCursorPosition > 0) {
+            setOtherText((prev) => {
+              const next =
+                prev.slice(0, otherCursorPosition - 1) +
+                prev.slice(otherCursorPosition);
+              return next;
+            });
+            setOtherCursorPosition((prev) => prev - 1);
+          }
+          return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+          setOtherText((prev) => {
+            const next =
+              prev.slice(0, otherCursorPosition) +
+              input +
+              prev.slice(otherCursorPosition);
+            return next;
+          });
+          setOtherCursorPosition((prev) => prev + input.length);
+          return;
         }
         return;
       }
@@ -229,7 +261,7 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
       } else if (state.selectedOption === "auto") {
         if (toolName === BASH_TOOL_NAME) {
           const rule = suggestedPrefix
-            ? `Bash(${suggestedPrefix}:*)`
+            ? `Bash(${suggestedPrefix}*)`
             : `Bash(${toolInput?.command})`;
           onDecision({
             behavior: "allow",
@@ -253,6 +285,29 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
       return;
     }
 
+    if (state.selectedOption === "alternative") {
+      if (key.leftArrow) {
+        setState((prev) => ({
+          ...prev,
+          alternativeCursorPosition: Math.max(
+            0,
+            prev.alternativeCursorPosition - 1,
+          ),
+        }));
+        return;
+      }
+      if (key.rightArrow) {
+        setState((prev) => ({
+          ...prev,
+          alternativeCursorPosition: Math.min(
+            prev.alternativeText.length,
+            prev.alternativeCursorPosition + 1,
+          ),
+        }));
+        return;
+      }
+    }
+
     // Handle arrow keys for navigation
     if (key.upArrow) {
       setState((prev) => {
@@ -287,27 +342,42 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
     // Handle text input for alternative option
     if (input && !key.ctrl && !key.meta && !("alt" in key && key.alt)) {
       // Focus on alternative option when user starts typing
-      setState((prev) => ({
-        selectedOption: "alternative",
-        alternativeText: prev.alternativeText + input,
-        hasUserInput: true,
-      }));
-      return;
-    }
-
-    // Handle backspace and delete (same behavior - delete one character)
-    if (key.backspace || key.delete) {
       setState((prev) => {
-        const newText = prev.alternativeText.slice(0, -1);
+        const nextText =
+          prev.alternativeText.slice(0, prev.alternativeCursorPosition) +
+          input +
+          prev.alternativeText.slice(prev.alternativeCursorPosition);
         return {
           ...prev,
           selectedOption: "alternative",
-          alternativeText: newText,
-          hasUserInput: newText.length > 0,
+          alternativeText: nextText,
+          alternativeCursorPosition:
+            prev.alternativeCursorPosition + input.length,
+          hasUserInput: true,
         };
       });
       return;
     }
+
+    // Handle backspace and delete
+    if (key.backspace || key.delete) {
+      setState((prev) => {
+        if (prev.alternativeCursorPosition > 0) {
+          const nextText =
+            prev.alternativeText.slice(0, prev.alternativeCursorPosition - 1) +
+            prev.alternativeText.slice(prev.alternativeCursorPosition);
+          return {
+            ...prev,
+            selectedOption: "alternative",
+            alternativeText: nextText,
+            alternativeCursorPosition: prev.alternativeCursorPosition - 1,
+            hasUserInput: nextText.length > 0,
+          };
+        }
+        return prev;
+      });
+      return;
+    }
   });
 
   const placeholderText = "Type here to tell Wave what to do differently";
@@ -329,11 +399,7 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
       </Text>
       <Text color="yellow">{getActionDescription(toolName, toolInput)}</Text>
 
-      <DiffDisplay
-        toolName={toolName}
-        parameters={JSON.stringify(toolInput)}
-        isExpanded={isExpanded}
-      />
+      <DiffDisplay toolName={toolName} parameters={JSON.stringify(toolInput)} />
 
       {toolName === ASK_USER_QUESTION_TOOL_NAME &&
         currentQuestion &&
@@ -383,7 +449,15 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
                           {isOther && isSelected && (
                             <Text>
                               :{" "}
-                              {otherText || (
+                              {otherText ? (
+                                <>
+                                  {otherText.slice(0, otherCursorPosition)}
+                                  <Text backgroundColor="white" color="black">
+                                    {otherText[otherCursorPosition] || " "}
+                                  </Text>
+                                  {otherText.slice(otherCursorPosition + 1)}
+                                </>
+                              ) : (
                                 <Text color="gray" dimColor>
                                   [Type your answer...]
                                 </Text>
@@ -474,8 +548,24 @@ export const Confirmation: React.FC<ConfirmationProps> = ({
                   </Text>
                 ) : (
                   <Text>
-                    {state.alternativeText ||
-                      "Type here to tell Wave what to do differently"}
+                    {state.alternativeText ? (
+                      <>
+                        {state.alternativeText.slice(
+                          0,
+                          state.alternativeCursorPosition,
+                        )}
+                        <Text backgroundColor="white" color="black">
+                          {state.alternativeText[
+                            state.alternativeCursorPosition
+                          ] || " "}
+                        </Text>
+                        {state.alternativeText.slice(
+                          state.alternativeCursorPosition + 1,
+                        )}
+                      </>
+                    ) : (
+                      "Type here to tell Wave what to do differently"
+                    )}
                   </Text>
                 )}
               </Text>

package/src/components/DiffDisplay.tsx

@@ -1,5 +1,5 @@
 import React, { useMemo } from "react";
-import { Box, Text, useStdout } from "ink";
+import { Box, Text } from "ink";
 import {
   WRITE_TOOL_NAME,
   EDIT_TOOL_NAME,
@@ -11,19 +11,12 @@ import { diffLines, diffWords } from "diff";
 interface DiffDisplayProps {
   toolName?: string;
   parameters?: string;
-  isExpanded?: boolean;
 }
 
 export const DiffDisplay: React.FC<DiffDisplayProps> = ({
   toolName,
   parameters,
-  isExpanded = false,
 }) => {
-  const { stdout } = useStdout();
-  const maxHeight = useMemo(() => {
-    return Math.max(5, (stdout?.rows || 24) - 20);
-  }, [stdout?.rows]);
-
   const showDiff =
     toolName &&
     [WRITE_TOOL_NAME, EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME].includes(toolName);
@@ -107,7 +100,7 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
     }
   };
 
-  // Render expanded diff display using word-level diff for all changes
+  // Render expanded diff display
   const renderExpandedDiff = () => {
     try {
       if (changes.length === 0) return null;
@@ -122,9 +115,8 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
             change.newContent || "",
           );
 
+          // Process line diffs
           const diffElements: React.ReactNode[] = [];
-
-          // Process line diffs and apply word-level diff to changed lines
           lineDiffs.forEach((part, partIndex) => {
             if (part.added) {
               const lines = part.value
@@ -175,70 +167,46 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
             }
           });
 
-          // Now look for pairs of removed/added lines that can be word-diffed
-          let i = 0;
-
-          while (i < diffElements.length) {
-            const current = diffElements[i];
-            const next =
-              i + 1 < diffElements.length ? diffElements[i + 1] : null;
-
-            // Check if we have a removed line followed by an added line
-            const currentKey = React.isValidElement(current) ? current.key : "";
-            const nextKey = React.isValidElement(next) ? next.key : "";
-
-            const isCurrentRemoved =
-              typeof currentKey === "string" && currentKey.includes("remove-");
-            const isNextAdded =
-              typeof nextKey === "string" && nextKey.includes("add-");
+          // If it's a single line change (one removed, one added), use word-level diff
+          if (
+            diffElements.length === 2 &&
+            React.isValidElement(diffElements[0]) &&
+            React.isValidElement(diffElements[1]) &&
+            typeof diffElements[0].key === "string" &&
+            diffElements[0].key.includes("remove-") &&
+            typeof diffElements[1].key === "string" &&
+            diffElements[1].key.includes("add-")
+          ) {
+            const removedText = extractTextFromElement(diffElements[0]);
+            const addedText = extractTextFromElement(diffElements[1]);
 
-            if (
-              isCurrentRemoved &&
-              isNextAdded &&
-              React.isValidElement(current) &&
-              React.isValidElement(next)
-            ) {
-              // Extract the text content from the removed and added lines
-              const removedText = extractTextFromElement(current);
-              const addedText = extractTextFromElement(next);
-
-              if (removedText && addedText) {
-                // Apply word-level diff
-                const { removedParts, addedParts } = renderWordLevelDiff(
-                  removedText,
-                  addedText,
-                  `word-${changeIndex}-${i}`,
-                );
-
-                allElements.push(
-                  <Box
-                    key={`word-diff-removed-${changeIndex}-${i}`}
-                    flexDirection="row"
-                  >
-                    <Text color="red">-</Text>
-                    {removedParts}
-                  </Box>,
-                );
-                allElements.push(
-                  <Box
-                    key={`word-diff-added-${changeIndex}-${i}`}
-                    flexDirection="row"
-                  >
-                    <Text color="green">+</Text>
-                    {addedParts}
-                  </Box>,
-                );
+            if (removedText && addedText) {
+              const { removedParts, addedParts } = renderWordLevelDiff(
+                removedText,
+                addedText,
+                `word-${changeIndex}`,
+              );
 
-                i += 2; // Skip the next element since we processed it
-              } else {
-                // Fallback to original elements
-                allElements.push(current);
-                i += 1;
-              }
+              allElements.push(
+                <Box
+                  key={`word-diff-removed-${changeIndex}`}
+                  flexDirection="row"
+                >
+                  <Text color="red">-</Text>
+                  {removedParts}
+                </Box>,
+              );
+              allElements.push(
+                <Box key={`word-diff-added-${changeIndex}`} flexDirection="row">
+                  <Text color="green">+</Text>
+                  {addedParts}
+                </Box>,
+              );
             } else {
-              allElements.push(current);
-              i += 1;
+              allElements.push(...diffElements);
             }
+          } else {
+            allElements.push(...diffElements);
           }
         } catch (error) {
           console.warn(
@@ -255,21 +223,7 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
         }
       });
 
-      const isTruncated = !isExpanded && allElements.length > maxHeight;
-      const displayElements = isTruncated
-        ? allElements.slice(0, maxHeight - 1)
-        : allElements;
-
-      return (
-        <Box flexDirection="column">
-          {displayElements}
-          {isTruncated && (
-            <Text color="yellow" dimColor>
-              ... (truncated {allElements.length - (maxHeight - 1)} more lines)
-            </Text>
-          )}
-        </Box>
-      );
+      return <Box flexDirection="column">{allElements}</Box>;
     } catch (error) {
       console.warn("Error rendering expanded diff:", error);
       return (
@@ -280,26 +234,6 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
     }
   };
 
-  // Helper function to extract text content from a React element
-  const extractTextFromElement = (element: React.ReactNode): string | null => {
-    if (!React.isValidElement(element)) return null;
-
-    // Navigate through Box -> Text structure
-    const children = (
-      element.props as unknown as { children?: React.ReactNode[] }
-    ).children;
-    if (Array.isArray(children) && children.length >= 2) {
-      const textElement = children[1]; // Second child should be the Text with content
-      if (
-        React.isValidElement(textElement) &&
-        (textElement.props as unknown as { children?: string }).children
-      ) {
-        return (textElement.props as unknown as { children: string }).children;
-      }
-    }
-    return null;
-  };
-
   // Don't render anything if no diff should be shown
   if (!showDiff) {
     return null;
@@ -316,3 +250,23 @@ export const DiffDisplay: React.FC<DiffDisplayProps> = ({
     </Box>
   );
 };
+
+// Helper function to extract text content from a React element
+const extractTextFromElement = (element: React.ReactNode): string | null => {
+  if (!React.isValidElement(element)) return null;
+
+  // Navigate through Box -> Text structure
+  const children = (
+    element.props as unknown as { children?: React.ReactNode[] }
+  ).children;
+  if (Array.isArray(children) && children.length >= 2) {
+    const textElement = children[1]; // Second child should be the Text with content
+    if (
+      React.isValidElement(textElement) &&
+      (textElement.props as unknown as { children?: string }).children
+    ) {
+      return (textElement.props as unknown as { children: string }).children;
+    }
+  }
+  return null;
+};