chore: remove some deadcodes (#17)

Author: y3owk1n

internal/accessibility/query.go

@@ -1,27 +1,10 @@
 package accessibility
 
 import (
-	"context"
 	"fmt"
 	"image"
-	"strings"
-	"time"
 )
 
-// Query represents a query for UI elements
-type Query struct {
-	Role          string
-	Title         string
-	TitleContains string
-	Enabled       *bool
-	Clickable     *bool
-	Scrollable    *bool
-	MinWidth      int
-	MinHeight     int
-	MaxResults    int
-	Timeout       time.Duration
-}
-
 func rectFromInfo(info *ElementInfo) image.Rectangle {
 	return image.Rect(
 		info.Position.X,
@@ -40,179 +23,6 @@ func expandRectangle(rect image.Rectangle, padding int) image.Rectangle {
 	)
 }
 
-// QueryBuilder helps build queries
-type QueryBuilder struct {
-	query Query
-}
-
-// NewQuery creates a new query builder
-func NewQuery() *QueryBuilder {
-	return &QueryBuilder{
-		query: Query{
-			MaxResults: 100,
-			Timeout:    5 * time.Second,
-		},
-	}
-}
-
-// WithRole sets the role filter
-func (qb *QueryBuilder) WithRole(role string) *QueryBuilder {
-	qb.query.Role = role
-	return qb
-}
-
-// WithTitle sets the exact title filter
-func (qb *QueryBuilder) WithTitle(title string) *QueryBuilder {
-	qb.query.Title = title
-	return qb
-}
-
-// WithTitleContains sets the title contains filter
-func (qb *QueryBuilder) WithTitleContains(text string) *QueryBuilder {
-	qb.query.TitleContains = text
-	return qb
-}
-
-// WithEnabled sets the enabled filter
-func (qb *QueryBuilder) WithEnabled(enabled bool) *QueryBuilder {
-	qb.query.Enabled = &enabled
-	return qb
-}
-
-// WithClickable sets the clickable filter
-func (qb *QueryBuilder) WithClickable(clickable bool) *QueryBuilder {
-	qb.query.Clickable = &clickable
-	return qb
-}
-
-// WithScrollable sets the scrollable filter
-func (qb *QueryBuilder) WithScrollable(scrollable bool) *QueryBuilder {
-	qb.query.Scrollable = &scrollable
-	return qb
-}
-
-// WithMinSize sets minimum size filter
-func (qb *QueryBuilder) WithMinSize(width, height int) *QueryBuilder {
-	qb.query.MinWidth = width
-	qb.query.MinHeight = height
-	return qb
-}
-
-// WithMaxResults sets the maximum number of results
-func (qb *QueryBuilder) WithMaxResults(max int) *QueryBuilder {
-	qb.query.MaxResults = max
-	return qb
-}
-
-// WithTimeout sets the query timeout
-func (qb *QueryBuilder) WithTimeout(timeout time.Duration) *QueryBuilder {
-	qb.query.Timeout = timeout
-	return qb
-}
-
-// Build returns the built query
-func (qb *QueryBuilder) Build() Query {
-	return qb.query
-}
-
-// Execute executes the query on the given tree
-func (q Query) Execute(tree *TreeNode) ([]*TreeNode, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), q.Timeout)
-	defer cancel()
-
-	results := make([]*TreeNode, 0)
-	resultsChan := make(chan *TreeNode, 100)
-	done := make(chan struct{})
-
-	// Start collection goroutine
-	go func() {
-		for node := range resultsChan {
-			results = append(results, node)
-			if q.MaxResults > 0 && len(results) >= q.MaxResults {
-				break
-			}
-		}
-		close(done)
-	}()
-
-	// Execute query
-	q.executeRecursive(ctx, tree, resultsChan)
-	close(resultsChan)
-
-	// Wait for collection to finish
-	select {
-	case <-done:
-	case <-ctx.Done():
-		return nil, fmt.Errorf("query timeout")
-	}
-
-	return results, nil
-}
-
-func (q Query) executeRecursive(ctx context.Context, node *TreeNode, results chan<- *TreeNode) {
-	select {
-	case <-ctx.Done():
-		return
-	default:
-	}
-
-	if q.matches(node) {
-		select {
-		case results <- node:
-		case <-ctx.Done():
-			return
-		}
-	}
-
-	for _, child := range node.Children {
-		q.executeRecursive(ctx, child, results)
-	}
-}
-
-func (q Query) matches(node *TreeNode) bool {
-	info := node.Info
-
-	// Role filter
-	if q.Role != "" && info.Role != q.Role {
-		return false
-	}
-
-	// Title filter
-	if q.Title != "" && info.Title != q.Title {
-		return false
-	}
-
-	// Title contains filter
-	if q.TitleContains != "" && !strings.Contains(strings.ToLower(info.Title), strings.ToLower(q.TitleContains)) {
-		return false
-	}
-
-	// Enabled filter
-	if q.Enabled != nil && info.IsEnabled != *q.Enabled {
-		return false
-	}
-
-	// Clickable filter
-	if q.Clickable != nil && node.Element.IsClickable() != *q.Clickable {
-		return false
-	}
-
-	// Scrollable filter
-	if q.Scrollable != nil && node.Element.IsScrollable() != *q.Scrollable {
-		return false
-	}
-
-	// Size filters
-	if q.MinWidth > 0 && info.Size.X < q.MinWidth {
-		return false
-	}
-	if q.MinHeight > 0 && info.Size.Y < q.MinHeight {
-		return false
-	}
-
-	return true
-}
-
 // GetClickableElements returns all clickable elements in the frontmost window
 func GetClickableElements() ([]*TreeNode, error) {
 	window := GetFrontmostWindow()
@@ -279,36 +89,6 @@ func GetScrollableElements() ([]*TreeNode, error) {
 	return tree.FindScrollableElements(), nil
 }
 
-// SearchElements searches for elements matching the query
-func SearchElements(query Query) ([]*TreeNode, error) {
-	window := GetFrontmostWindow()
-	if window == nil {
-		return nil, fmt.Errorf("no frontmost window")
-	}
-	defer window.Release()
-
-	opts := DefaultTreeOptions()
-	opts.MaxDepth = 15
-
-	tree, err := BuildTree(window, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	return query.Execute(tree)
-}
-
-// FuzzySearch performs a fuzzy search for elements by title
-func FuzzySearch(searchText string, maxResults int) ([]*TreeNode, error) {
-	query := NewQuery().
-		WithTitleContains(searchText).
-		WithEnabled(true).
-		WithMaxResults(maxResults).
-		Build()
-
-	return SearchElements(query)
-}
-
 // GetMenuBarClickableElements returns clickable elements from the focused app's menu bar
 func GetMenuBarClickableElements() ([]*TreeNode, error) {
 	app := GetFocusedApplication()

internal/accessibility/tree.go

@@ -3,7 +3,6 @@ package accessibility
 import (
 	"context"
 	"sync"
-	"time"
 )
 
 // TreeNode represents a node in the accessibility tree
@@ -193,30 +192,6 @@ func (n *TreeNode) FindScrollableElements() []*TreeNode {
 	return result
 }
 
-// FindByRole finds all elements with the specified role
-func (n *TreeNode) FindByRole(role string) []*TreeNode {
-	var result []*TreeNode
-	n.walkTree(func(node *TreeNode) bool {
-		if node.Info.Role == role {
-			result = append(result, node)
-		}
-		return true
-	})
-	return result
-}
-
-// FindByTitle finds all elements with the specified title
-func (n *TreeNode) FindByTitle(title string) []*TreeNode {
-	var result []*TreeNode
-	n.walkTree(func(node *TreeNode) bool {
-		if node.Info.Title == title {
-			result = append(result, node)
-		}
-		return true
-	})
-	return result
-}
-
 // walkTree walks the tree and calls the visitor function for each node
 func (n *TreeNode) walkTree(visitor func(*TreeNode) bool) {
 	if !visitor(n) {
@@ -227,114 +202,3 @@ func (n *TreeNode) walkTree(visitor func(*TreeNode) bool) {
 		child.walkTree(visitor)
 	}
 }
-
-// GetDepth returns the depth of the tree
-func (n *TreeNode) GetDepth() int {
-	if len(n.Children) == 0 {
-		return 1
-	}
-
-	maxChildDepth := 0
-	for _, child := range n.Children {
-		depth := child.GetDepth()
-		if depth > maxChildDepth {
-			maxChildDepth = depth
-		}
-	}
-
-	return maxChildDepth + 1
-}
-
-// GetTotalNodes returns the total number of nodes in the tree
-func (n *TreeNode) GetTotalNodes() int {
-	count := 1
-	for _, child := range n.Children {
-		count += child.GetTotalNodes()
-	}
-	return count
-}
-
-// Cache for UI element trees
-type TreeCache struct {
-	cache         map[string]*CachedTree
-	mu            sync.RWMutex
-	maxAge        time.Duration
-	cleanupTicker *time.Ticker
-}
-
-type CachedTree struct {
-	Tree      *TreeNode
-	Timestamp time.Time
-}
-
-// NewTreeCache creates a new tree cache
-func NewTreeCache(maxAge time.Duration) *TreeCache {
-	tc := &TreeCache{
-		cache:  make(map[string]*CachedTree),
-		maxAge: maxAge,
-	}
-
-	// Start cleanup goroutine
-	tc.cleanupTicker = time.NewTicker(maxAge / 2)
-	go tc.cleanup()
-
-	return tc
-}
-
-// Get retrieves a cached tree
-func (tc *TreeCache) Get(key string) (*TreeNode, bool) {
-	tc.mu.RLock()
-	defer tc.mu.RUnlock()
-
-	cached, ok := tc.cache[key]
-	if !ok {
-		return nil, false
-	}
-
-	// Check if cache is still valid
-	if time.Since(cached.Timestamp) > tc.maxAge {
-		return nil, false
-	}
-
-	return cached.Tree, true
-}
-
-// Set stores a tree in the cache
-func (tc *TreeCache) Set(key string, tree *TreeNode) {
-	tc.mu.Lock()
-	defer tc.mu.Unlock()
-
-	tc.cache[key] = &CachedTree{
-		Tree:      tree,
-		Timestamp: time.Now(),
-	}
-}
-
-// Clear clears the cache
-func (tc *TreeCache) Clear() {
-	tc.mu.Lock()
-	defer tc.mu.Unlock()
-
-	tc.cache = make(map[string]*CachedTree)
-}
-
-// cleanup removes expired entries
-func (tc *TreeCache) cleanup() {
-	for range tc.cleanupTicker.C {
-		tc.mu.Lock()
-		now := time.Now()
-		for key, cached := range tc.cache {
-			if now.Sub(cached.Timestamp) > tc.maxAge {
-				delete(tc.cache, key)
-			}
-		}
-		tc.mu.Unlock()
-	}
-}
-
-// Stop stops the cleanup goroutine
-func (tc *TreeCache) Stop() {
-	if tc.cleanupTicker != nil {
-		tc.cleanupTicker.Stop()
-	}
-}