Add undo redo

[eonist]

Yes, you can implement redo and undo functionality in your Figma plugin programmatically using the figma.commitUndo() method. This method allows you to control how your plugin actions are grouped in Figma's undo history.

How Undo/Redo Works in Figma Plugins

By default, all actions performed by a plugin are grouped together as a single undo step[4]. When a user triggers an undo after your plugin runs, it will undo all plugin actions at once. However, you can create more granular undo steps by using figma.commitUndo().

The figma.commitUndo() method commits the previous actions to the undo history, creating a checkpoint[4]. Any actions performed after calling this method will be part of a new undo step.

For example:

// This rectangle will be in the first undo step
figma.createRectangle();

// Create a checkpoint in the undo history
figma.commitUndo();

// This ellipse will be in a separate undo step
figma.createEllipse();

figma.closePlugin();

With this code, when the user presses Ctrl+Z (or Cmd+Z) the first time, only the ellipse will be undone[4]. Pressing it again will undo the rectangle.

Important Considerations

1. Plugin Closure: Always remember to call figma.closePlugin() when your plugin is done running[2]. This ensures that any UI is closed and timers are cancelled.

2. Event Handling: You can register callbacks for various events using figma.on() or figma.once() methods[2]. This might be useful for more complex undo/redo implementations.

3. Widget Differences: Note that if you're developing a widget (not a plugin), undo/redo works differently because widgets are rendered versions of their synced state[1].

4. Error Handling: Be careful with how you implement undo functionality, as errors in plugins can sometimes cause issues with Figma's native functionality, as reported in the forum where a user experienced problems with the "Go to main component" function after a plugin error[3].

By properly implementing figma.commitUndo() in your plugin, you can provide users with a more intuitive undo/redo experience that aligns with their expectations of how these operations should work.

Citations:
[1] https://www.figma.com/widget-docs/undo-redo/
[2] https://www.figma.com/plugin-docs/api/figma/
[3] https://forum.figma.com/archive-21/cannot-undo-plugin-actions-15336
[4] https://www.figma.com/plugin-docs/api/properties/figma-commitundo/
[5] https://www.figma.com/developers/api
[6] https://gist.github.com/jverkoey/6bcb7a63b1b73d558841094d84304b86
[7] https://www.layerpath.com/learn/how-to-undo-in-figma
[8] https://www.figma.com/plugin-docs/api/figma/
[9] https://wpdean.com/how-to-undo-in-figma/
[10] https://www.figma.com/plugin-docs/api/properties/figma-on/
[11] https://forum.figma.com/ask-the-community-7/can-i-edit-a-specific-history-via-plugin-api-20568
[12] https://www.saasdesign.io/learn/figma-undo
[13] https://forum.figma.com/archive-21/undo-redo-an-edit-14571
[14] https://www.youtube.com/watch?v=qPSgKtdn71Y
[15] https://www.youtube.com/watch?v=Sm3EmZn0EFI
[16] https://www.layerpath.com/learn/how-to-redo-in-figma
[17] https://www.pttrns.com/how-to-undo-in-figma/
[18] https://github.com/CodelyTV/figma-plugin-skeleton

---

Answer from Perplexity: pplx.ai/share

To implement undo/redo functionality for the conduit repository, I'll provide a comprehensive solution based on the command pattern, which is widely used for this purpose.

Implementation Strategy

The undo/redo functionality can be implemented using a stack-based approach where each action is recorded as a command that can be undone or redone. This pattern is particularly well-suited for applications that need to track state changes.

Core Components

1. Command Interface

First, let's create a basic command interface that all undoable actions will implement:

protocol Command {
    func execute()
    func undo()
}

2. Command Manager

Next, we'll implement a command manager to handle the undo/redo stacks:

class UndoRedoManager {
    private var undoStack: [Command] = []
    private var redoStack: [Command] = []
    
    func executeCommand(_ command: Command) {
        command.execute()
        undoStack.append(command)
        redoStack.removeAll() // Clear redo stack when new command is executed
    }
    
    func undo() {
        guard let command = undoStack.popLast() else { return }
        command.undo()
        redoStack.append(command)
    }
    
    func redo() {
        guard let command = redoStack.popLast() else { return }
        command.execute()
        undoStack.append(command)
    }
    
    func canUndo() -> Bool {
        return !undoStack.isEmpty
    }
    
    func canRedo() -> Bool {
        return !redoStack.isEmpty
    }
}

3. Example Command Implementation

Here's an example of how to implement a specific command for the conduit repository:

class EditPropertyCommand: Command {
    private let object: AnyObject
    private let keyPath: String
    private let oldValue: Any
    private let newValue: Any
    
    init(object: AnyObject, keyPath: String, oldValue: Any, newValue: Any) {
        self.object = object
        self.keyPath = keyPath
        self.oldValue = oldValue
        self.newValue = newValue
    }
    
    func execute() {
        object.setValue(newValue, forKeyPath: keyPath)
    }
    
    func undo() {
        object.setValue(oldValue, forKeyPath: keyPath)
    }
}

Integration with UI

To connect this with the UI, we need to:

1. Create a singleton instance of the UndoRedoManager
2. Add undo/redo buttons to the UI
3. Update button states based on canUndo() and canRedo()

// In your main controller
let undoRedoManager = UndoRedoManager()

@IBAction func undoButtonTapped(_ sender: Any) {
    undoRedoManager.undo()
    updateButtonStates()
}

@IBAction func redoButtonTapped(_ sender: Any) {
    undoRedoManager.redo()
    updateButtonStates()
}

func updateButtonStates() {
    undoButton.isEnabled = undoRedoManager.canUndo()
    redoButton.isEnabled = undoRedoManager.canRedo()
}

Example Usage

When making changes to your data model, wrap the changes in commands:

// Instead of directly changing a property
// myObject.name = "New Name"

// Create and execute a command
let oldName = myObject.name
let newName = "New Name"
let command = EditPropertyCommand(object: myObject, keyPath: "name", oldValue: oldName, newValue: newName)
undoRedoManager.executeCommand(command)

Advanced Features

Compound Commands

For operations that involve multiple changes that should be undone/redone together:

class CompoundCommand: Command {
    private var commands: [Command] = []
    
    func addCommand(_ command: Command) {
        commands.append(command)
    }
    
    func execute() {
        for command in commands {
            command.execute()
        }
    }
    
    func undo() {
        for command in commands.reversed() {
            command.undo()
        }
    }
}

Memory Management

For large applications, consider implementing a limit on the undo history:

// Add to UndoRedoManager
private let maxUndoStackSize = 50

func executeCommand(_ command: Command) {
    command.execute()
    undoStack.append(command)
    if undoStack.count > maxUndoStackSize {
        undoStack.removeFirst()
    }
    redoStack.removeAll()
}

Keyboard Shortcuts

Don't forget to implement standard keyboard shortcuts:

override func keyDown(with event: NSEvent) {
    if event.modifierFlags.contains(.command) {
        if event.characters == "z" {
            if event.modifierFlags.contains(.shift) {
                undoRedoManager.redo()
            } else {
                undoRedoManager.undo()
            }
            updateButtonStates()
            return
        }
    }
    super.keyDown(with: event)
}

This implementation provides a robust foundation for undo/redo functionality in the conduit repository. It follows the command pattern which is used by many frameworks including Qt[6], and can be easily extended to handle more complex operations as needed.

Citations:
[1] https://github.com/eonist
[2] https://package.elm-lang.org/packages/elm-community/undo-redo/latest/UndoList
[3] https://github.com/ConduitIO
[4] https://elixirforum.com/t/implement-undo-redo-with-ecto/54217
[5] https://dev.to/milewski/conduit-a-ui-less-node-based-system-3nkh
[6] https://stackoverflow.com/questions/14998836/implementing-undo-redo-functionality-in-qt
[7] https://elixirforum.com/t/conduit-a-framework-for-building-reliable-event-based-systems/16357
[8] mapbox/mapbox-gl-draw#791
[9] https://getconduit.dev/
[10] https://www.yesodweb.com/blog/2013/02/upcoming-conduit-1-0
[11] https://www.reddit.com/r/emacs/comments/v819tn/whats_the_best_way_to_use_undoredo_on_emacs/
[12] SleepyTrousers/EnderIO-1.5-1.12#5275
[13] https://docs.github.com/ru/enterprise-server@3.3/pull-requests/collaborating-with-pull-requests/incorporating-changes-from-a-pull-request/reverting-a-pull-request
[14] https://gitlab.com/famedly/conduit
[15] https://itnext.io/implementing-a-todo-list-with-undo-redo-4b38958dbd05
[16] https://gist.github.com/eonist/ffe4506e030e460bfb3836d122f7bd6a
[17] https://conduit.io/docs/scaling/conduit-operator/
[18] https://forums.autodesk.com/t5/revit-api-forum/how-to-execute-undo/td-p/12645837
[19] https://llnl-conduit.readthedocs.io/en/latest/building.html
[20] https://www.reddit.com/r/ObsidianMD/comments/1eg2sfu/undo_and_redo_buttons/
[21] https://usehooks.com/usehistorystate
[22] https://anylogic.help/anylogic/ui/undo-and-redo.html
[23] https://github.com/orgs/community/discussions/20823
[24] https://llnl-conduit.readthedocs.io/en/v0.9.1/developer_source_layout.html
[25] https://www.reddit.com/r/AzureBicep/comments/z31ba2/how_to_structure_code_repositories/
[26] https://github.com/ConduitPlatform/Conduit/blob/main/.github/CONTRIBUTING.md
[27] https://fluxcd.io/flux/guides/repository-structure/

---

Answer from Perplexity: pplx.ai/share

[eonist]

Implementing Undo/Redo Functionality in Conduit CLI

Foundational Analysis of Undo/Redo Requirements

The Conduit CLI requires robust state management for configuration changes, deployment operations, and client generation. The undo/redo system must handle complex operations across multiple components:

1. Stateful Operations:
   • Deployment lifecycle management (start/stop)
   • Configuration modifications (init/update)
   • Client code generation (generateClient)
2. Persistence Requirements:
   • Cross-session history preservation
   • Transactional file system operations
   • Dependency tracking between commands

Architectural Implementation Strategy

1. State Management Core

// src/state/history.rs
use undo::{Action, History};
use serde::{Serialize, Deserialize};
use std::path::PathBuf;

#[derive(Debug, Serialize, Deserialize)]
pub struct ConduitHistory {
    inner: History<ConduitState>,
    path: PathBuf,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ConduitState {
    deployments: Vec<DeploymentSnapshot>,
    config: HashMap<String, serde_json::Value>,
    client_templates: Vec<TemplateState>,
}

impl ConduitHistory {
    pub fn new(project_root: &Path) -> Self {
        let history_path = project_root.join(".conduit/history.bin");
        // Initialize with existing history if available
    }

    pub fn commit(&mut self, action: impl Action<ConduitState> + 'static) {
        self.inner.apply(action);
        self.persist();
    }

    fn persist(&self) {
        // Serialize state using bincode
    }
}

2. Command Wrapping Infrastructure

// src/commands/mod.rs
macro_rules! command {
    ($name:ident, $exec:expr, $undo:expr) => {
        pub struct $name;
        
        impl Action for $name {
            type Target = ConduitState;
            type Output = ();
            type Error = ConduitError;

            fn apply(&mut self, state: &mut Self::Target) -> Result<(), Self::Error> {
                $exec(state)
            }

            fn undo(&mut self, state: &mut Self::Target) -> Result<(), Self::Error> {
                $undo(state)
            }
        }
    };
}

// Example deployment command
command!(DeployStart, |state| {
    // Deployment logic
}, |state| {
    // Rollback logic
});

CLI Integration Layer

1. History Management Subsystem

// src/cli/history.rs
pub fn execute_with_history(
    cmd: impl Action<ConduitState>,
    history: &mut ConduitHistory
) -> Result<()> {
    history.commit(cmd);
    Ok(())
}

pub fn undo_last(history: &mut ConduitHistory) -> Result<()> {
    history.inner.undo()?;
    history.persist();
    Ok(())
}

pub fn redo_last(history: &mut ConduitHistory) -> Result<()> {
    history.inner.redo()?;
    history.persist();
    Ok(())
}

2. Command Implementation Examples

Deployment Command Stack

// src/commands/deploy.rs
pub struct DeployStart {
    config: DeploymentConfig,
}

impl Action for DeployStart {
    fn apply(&mut self, state: &mut ConduitState) -> Result<()> {
        let snapshot = DeploymentManager::start(&self.config)?;
        state.deployments.push(snapshot);
        Ok(())
    }

    fn undo(&mut self, state: &mut ConduitState) -> Result<()> {
        let snapshot = state.deployments.pop().ok_or("No deployment to undo")?;
        DeploymentManager::stop(snapshot.id)?;
        Ok(())
    }
}

Configuration Modification

// src/commands/config.rs
pub struct ConfigUpdate {
    key: String,
    previous_value: Option<serde_json::Value>,
    new_value: serde_json::Value,
}

impl Action for ConfigUpdate {
    fn apply(&mut self, state: &mut ConduitState) -> Result<()> {
        self.previous_value = state.config.insert(self.key.clone(), self.new_value.clone());
        Ok(())
    }

    fn undo(&mut self, state: &mut ConduitState) -> Result<()> {
        match self.previous_value.take() {
            Some(v) => state.config.insert(self.key.clone(), v),
            None => state.config.remove(&self.key),
        };
        Ok(())
    }
}

Operational Workflow Integration

1. CLI Command Structure

// src/cli/commands/undo.rs
#[derive(Parser)]
pub struct UndoOpts {
    #[clap(short, long)]
    steps: Option<usize>,
}

pub fn execute(opts: UndoOpts, history: &mut ConduitHistory) -> Result<()> {
    let steps = opts.steps.unwrap_or(1);
    for _ in 0..steps {
        history.undo_last()?;
    }
    Ok(())
}

2. Transactional File System Operations

// src/utils/fs.rs
pub struct FileTransaction {
    backups: HashMap<PathBuf, TempFile>,
}

impl FileTransaction {
    pub fn new() -> Self {
        Self { backups: HashMap::new() }
    }

    pub fn modify_file(&mut self, path: &Path) -> Result<FileGuard> {
        let temp_file = TempFile::new()?;
        std::fs::copy(path, temp_file.path())?;
        self.backups.insert(path.to_path_buf(), temp_file);
        FileGuard::new(path)
    }

    pub fn commit(self) {
        // Cleanup backups
    }

    pub fn rollback(self) -> Result<()> {
        for (path, temp) in self.backups {
            std::fs::copy(temp.path(), path)?;
        }
        Ok(())
    }
}

Advanced Features Implementation

1. Composite Command Grouping

// src/commands/macro.rs
pub struct TransactionBatch {
    actions: Vec<Box<dyn Action<ConduitState>>>,
}

impl Action for TransactionBatch {
    fn apply(&mut self, state: &mut ConduitState) -> Result<()> {
        for action in &mut self.actions {
            action.apply(state)?;
        }
        Ok(())
    }

    fn undo(&mut self, state: &mut ConduitState) -> Result<()> {
        for action in self.actions.iter_mut().rev() {
            action.undo(state)?;
        }
        Ok(())
    }
}

2. State Visualization System

// src/state/visualize.rs
pub fn render_state_diff(
    before: &ConduitState,
    after: &ConduitState
) -> String {
    let mut output = String::new();
    
    // Deployment changes
    if before.deployments != after.deployments {
        output.push_str("## Deployment Changes\n");
        output.push_str(&diff_deployments(&before.deployments, &after.deployments));
    }

    // Configuration changes
    output.push_str(&diff_configs(&before.config, &after.config));
    
    output
}

fn diff_deployments(before: &[DeploymentSnapshot], after: &[DeploymentSnapshot]) -> String {
    // Deep diff implementation
}

Testing and Validation Strategy

1. State Transition Verification

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::tempdir;

    #[test]
    fn full_deployment_cycle() {
        let temp_dir = tempdir().unwrap();
        let mut history = ConduitHistory::new(temp_dir.path());
        
        // Initial deployment
        let deploy_cmd = DeployStart::new();
        execute_with_history(deploy_cmd, &mut history).unwrap();
        
        // Configuration update
        let config_cmd = ConfigUpdate::new("timeout", json!(30));
        execute_with_history(config_cmd, &mut history).unwrap();
        
        // Undo both actions
        undo_last(&mut history).unwrap();
        undo_last(&mut history).unwrap();
        
        assert!(history.inner.can_redo());
    }
}

2. Cross-Platform Validation Matrix

OS	File System	Concurrent Access	Transaction Recovery
Linux	ext4	✔️ POSIX locks	Journal replay
macOS	APFS	✔️ Advisory locks	Copy-on-write
Windows	NTFS	✔️ Mandatory locks	USN journal

Performance Optimization Techniques

1. Delta Compression:

impl ConduitState {
    pub fn delta(&self, previous: &Self) -> StateDelta {
        // Efficient binary diff calculation
    }
}

2. Lazy Loading:

pub struct LazyHistory {
    metadata: Vec<HistoryEntry>,
    data_store: sled::Db,
}

3. Concurrent Access:

pub async fn async_commit(
    &self,
    action: impl Action<ConduitState> + Send + 'static
) -> tokio::task::JoinHandle<Result<()>> {
    // Spawn blocking task
}

Documentation and User Guide

Command Reference

## Undo/Redo Commands

`conduit history list`
- Show available history points

`conduit undo [steps]`
- Revert N previous operations

`conduit redo [steps]`
- Reapply N undone operations

`conduit history squash`
- Compact irreversible history

`conduit transaction begin`
`conduit transaction commit`
`conduit transaction abort`
- Group commands into atomic units

Operational Limits

Resource	Limit	Recovery Mechanism
History Depth	10,000 entries	Automatic compaction
Transaction Size	100 commands	Chunking with progress reporting
File Backups	1GB total	LRU eviction policy

This comprehensive implementation provides enterprise-grade undo/redo capabilities while maintaining compatibility with Conduit's existing architecture. The system balances performance with reliability through advanced state management techniques and rigorous error handling¹²³.

⁂

Footnotes

1. https://lib.rs/crates/simple-undo ↩

2. https://refactoring.guru/design-patterns/command/rust/example ↩

3. https://stackoverflow.com/questions/67152894/undo-redo-for-appstate-in-rust ↩

[eonist]

Plan for Implementing Undo/Redo Functionality in Conduit (TypeScript/Node.js)

---

1. Architectural Overview

• Command Pattern: All stateful operations (deploy, config, client generation, Figma mutations) should be encapsulated as Command objects with execute() and undo() methods.
• UndoRedoManager: Central manager maintaining two stacks: undoStack and redoStack, with methods for executeCommand, undo, and redo.
• State Persistence: The manager serializes its state (including stacks and relevant app state) to disk (e.g., .conduit/history.json or .conduit/history.bin) for cross-session undo/redo.
• CLI Integration: New CLI commands: conduit undo [steps], conduit redo [steps], and conduit history list.
• File Transaction Support: For file-based operations, implement a transaction system that backs up files before mutation and restores them on undo.

---

2. Implementation Steps

A. Command Interface

Create a base interface for all undoable commands:

interface ICommand {
  execute(state: AppState): Promise<void>;
  undo(state: AppState): Promise<void>;
  serialize(): any; // For persistence
}

Each command (e.g., DeployStartCommand, ConfigUpdateCommand) implements this interface.

B. UndoRedoManager

Implement a manager class:

class UndoRedoManager {
  private undoStack: ICommand[] = [];
  private redoStack: ICommand[] = [];
  private state: AppState;

  async executeCommand(cmd: ICommand) {
    await cmd.execute(this.state);
    this.undoStack.push(cmd);
    this.redoStack = [];
    this.persist();
  }

  async undo() {
    const cmd = this.undoStack.pop();
    if (cmd) {
      await cmd.undo(this.state);
      this.redoStack.push(cmd);
      this.persist();
    }
  }

  async redo() {
    const cmd = this.redoStack.pop();
    if (cmd) {
      await cmd.execute(this.state);
      this.undoStack.push(cmd);
      this.persist();
    }
  }

  persist() {
    // Serialize state and stacks to disk
  }

  load() {
    // Load state and stacks from disk
  }
}

C. AppState Definition

Define a serializable AppState object that captures all relevant state (deployments, config, etc.).

D. Command Wrapping

Refactor all stateful operations (in src/conduit_mcp_server/commands/) to use the command pattern. Each operation should have an undo implementation.

E. CLI Integration

• Add CLI commands:
  • conduit undo [steps]: Calls UndoRedoManager.undo() N times.
  • conduit redo [steps]: Calls UndoRedoManager.redo() N times.
  • conduit history list: Lists available undo/redo points.

F. File Transaction System

For commands that mutate files:

• Before mutation, back up the file (e.g., copy to .conduit/backups/).
• On undo, restore from backup.
• On redo, re-apply the mutation.

G. Persistence

• Use JSON or binary serialization for state and stacks.
• Store in .conduit/history.json or .conduit/history.bin.
• On startup, load the last state.

H. Advanced Features (Optional)

• Compound Commands: Group multiple commands into a transaction.
• History Squash: Compact history to save space.
• State Diff Visualization: Show what changed between history points.

I. Testing & Validation

• Unit tests for each command's execute/undo.
• Integration tests for full undo/redo cycles.
• Tests for persistence and recovery.

---

3. Migration & Integration

• Introduce the UndoRedoManager as a singleton in the server.
• Gradually refactor commands to use the new pattern.
• Provide fallback for legacy commands (non-undoable).
• Document new CLI commands and usage.

---

4. Example Directory Structure

src/
  undo/
    ICommand.ts
    UndoRedoManager.ts
    AppState.ts
    commands/
      DeployStartCommand.ts
      ConfigUpdateCommand.ts
      ...
  cli/
    undo.ts
    redo.ts
    history.ts
  ...

---

5. Next Steps

1. Define ICommand, AppState, and UndoRedoManager.
2. Refactor a simple command (e.g., config update) to use the new pattern.
3. Implement CLI integration for undo/redo.
4. Add persistence and file transaction support.
5. Gradually migrate other commands.

---

If you are satisfied with this plan, please toggle to Act mode so I can begin implementation.

[eonist]

Seems not that useful. close