jpmschweitzer/clide
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add search-and-replace across files

Browse Source 
Builds on the find-in-files engine. A replace engine applies the
query's replacement to each matching file — literal or regex with
capture-group expansion ($1, $&, $$) — and reports per-file, per-line
before/after edits computed with the same logic the apply uses, so
preview and apply never disagree.

The search.replace command previews (no disk writes) or applies
(writing each changed file through the workspace path-safety guard).
The panel gains a Replace field: each match row previews its rewritten
line, and Replace all is gated on a clean git working tree (git is the
undo) plus a confirmation before it writes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
jpmschweitzer
2026-05-31 21:41:09 +02:00
co-authored by Claude Opus 4.8
parent d26a1f895c
commit 4aed6c12a5
11 changed files with 821 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/builtin/search/src/find_in_files_controller.dart
+37
View File
@@ -27,6 +27,7 @@ class FindInFilesController extends ChangeNotifier {
bool ignoreCase = false;
String includeGlobs = '';
String excludeGlobs = '';
String replacement = '';
// -- Result state ---------------------------------------------------------
String? _activeSearchId;
@@ -67,6 +68,42 @@ class FindInFilesController extends ChangeNotifier {
set include(String v) => includeGlobs = v;
set exclude(String v) => excludeGlobs = v;
void setReplacement(String v) {
if (replacement == v) return;
replacement = v;
notifyListeners();
}
/// True when the git working tree has no changes — the safety gate for
/// applying a destructive multi-file replace (the user's chosen model:
/// git is the lossless undo layer).
Future<bool> isWorkingTreeClean() async {
final r = await ipc.request('git.status');
return r.ok && r.data['clean'] == true;
}
/// Apply the current replacement across all matches, then refresh the
/// results. Returns the number of files changed and matches replaced.
/// Callers must gate on [isWorkingTreeClean] + user confirmation first.
Future<({int files, int count})> applyReplace() async {
final r = await ipc.request('search.replace', args: {
'pattern': pattern,
'regex': regex,
'ignoreCase': ignoreCase,
'include': _split(includeGlobs),
'exclude': _split(excludeGlobs),
'replacement': replacement,
'apply': true,
});
final files = (r.data['filesChanged'] as num?)?.toInt() ?? 0;
final count = (r.data['totalCount'] as num?)?.toInt() ?? 0;
await run(pattern); // refresh the match list against the new content
return (files: files, count: count);
}
/// The query the panel is currently running (for preview rendering).
SearchQuery get query => SearchQuery(pattern: pattern, regex: regex, ignoreCase: ignoreCase);
/// Start a search with the current query/options. Cancels any
/// in-flight search first and clears prior results.
Future<void> run(String query) async {
lib/builtin/search/src/search_panel_view.dart
+221 -8
View File
@@ -6,6 +6,7 @@ library;
import 'package:clide/builtin/search/src/find_in_files_controller.dart';
import 'package:clide/kernel/kernel.dart';
import 'package:clide/src/search/match.dart';
import 'package:clide/src/search/replace_engine.dart';
import 'package:clide/widgets/widgets.dart';
import 'package:flutter/widgets.dart';
@@ -33,6 +34,26 @@ class _SearchPanelViewState extends State<SearchPanelView> {
super.dispose();
}
Future<void> _replaceAll() async {
final c = _controller!;
if (c.replacement.isEmpty || c.matchCount == 0) return;
final dialog = ClideKernel.of(context).dialog;
if (!await c.isWorkingTreeClean()) {
await dialog.show<Object>((ctx, dismiss) => _MessageDialog(
title: 'Working tree not clean',
body: 'Commit or stash your changes before replacing — git is the only undo.',
dismiss: dismiss,
));
return;
}
final confirmed = await dialog.show<bool>((ctx, dismiss) => _ConfirmDialog(
body: 'Replace ${c.matchCount} match(es) across ${c.fileCount} file(s)? This cannot be undone in clide.',
dismiss: dismiss,
));
if (confirmed != true) return;
await c.applyReplace();
}
@override
Widget build(BuildContext context) {
final tokens = ClideTheme.of(context).surface;
@@ -79,6 +100,18 @@ class _SearchPanelViewState extends State<SearchPanelView> {
],
),
const SizedBox(height: 6),
Row(
children: [
Expanded(child: ClideFilterBox(hint: 'Replace', debounce: Duration.zero, onChanged: c.setReplacement)),
const SizedBox(width: 6),
_ReplaceAllButton(
enabled: c.replacement.isNotEmpty && c.matchCount > 0,
tokens: tokens,
onTap: _replaceAll,
),
],
),
const SizedBox(height: 6),
ClideFilterBox(hint: 'files to include (e.g. *.dart)', debounce: Duration.zero, onChanged: (v) => c.include = v),
const SizedBox(height: 4),
ClideFilterBox(hint: 'files to exclude', debounce: Duration.zero, onChanged: (v) => c.exclude = v),
@@ -94,7 +127,15 @@ class _SearchPanelViewState extends State<SearchPanelView> {
child: ListView(
padding: EdgeInsets.zero,
children: [
for (final entry in groups.entries) _FileGroup(path: entry.key, matches: entry.value, tokens: tokens, onTap: c.openMatch),
for (final entry in groups.entries)
_FileGroup(
path: entry.key,
matches: entry.value,
tokens: tokens,
onTap: c.openMatch,
query: c.query,
replacement: c.replacement,
),
],
),
),
@@ -169,12 +210,21 @@ class _StatusText extends StatelessWidget {
}
class _FileGroup extends StatelessWidget {
const _FileGroup({required this.path, required this.matches, required this.tokens, required this.onTap});
const _FileGroup({
required this.path,
required this.matches,
required this.tokens,
required this.onTap,
required this.query,
required this.replacement,
});
final String path;
final List<SearchMatch> matches;
final SurfaceTokens tokens;
final void Function(SearchMatch) onTap;
final SearchQuery query;
final String replacement;
@override
Widget build(BuildContext context) {
@@ -193,18 +243,26 @@ class _FileGroup extends StatelessWidget {
],
),
),
for (final m in matches) _MatchRow(match: m, tokens: tokens, onTap: () => onTap(m)),
for (final m in matches) _MatchRow(match: m, tokens: tokens, onTap: () => onTap(m), query: query, replacement: replacement),
],
);
}
}
class _MatchRow extends StatelessWidget {
const _MatchRow({required this.match, required this.tokens, required this.onTap});
const _MatchRow({
required this.match,
required this.tokens,
required this.onTap,
required this.query,
required this.replacement,
});
final SearchMatch match;
final SurfaceTokens tokens;
final VoidCallback onTap;
final SearchQuery query;
final String replacement;
@override
Widget build(BuildContext context) {
@@ -224,7 +282,7 @@ class _MatchRow extends StatelessWidget {
width: 36,
child: ClideText('${match.line}', fontSize: clideFontCaption, fontFamily: clideMonoFamily, color: tokens.globalTextMuted),
),
Expanded(child: _highlighted()),
Expanded(child: replacement.isEmpty ? _highlighted() : _preview()),
],
),
),
@@ -232,19 +290,174 @@ class _MatchRow extends StatelessWidget {
);
}
TextStyle get _base => TextStyle(fontFamily: clideMonoFamily, fontSize: clideFontCaption, color: tokens.sidebarForeground);
Widget _highlighted() {
final line = match.preview;
final start = match.matchStart.clamp(0, line.length);
final end = match.matchEnd.clamp(start, line.length);
final base = TextStyle(fontFamily: clideMonoFamily, fontSize: clideFontCaption, color: tokens.sidebarForeground);
return RichText(
maxLines: 1,
overflow: TextOverflow.ellipsis,
text: TextSpan(style: base, children: [
text: TextSpan(style: _base, children: [
TextSpan(text: line.substring(0, start)),
TextSpan(text: line.substring(start, end), style: base.copyWith(color: tokens.globalFocus, fontWeight: FontWeight.bold)),
TextSpan(text: line.substring(start, end), style: _base.copyWith(color: tokens.globalFocus, fontWeight: FontWeight.bold)),
TextSpan(text: line.substring(end)),
]),
);
}
/// Replace-preview: the original line struck through, then the
/// rewritten line (computed with the same engine the apply uses).
Widget _preview() {
final after = applyToText(match.preview, query, replacement).text;
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
RichText(
maxLines: 1,
overflow: TextOverflow.ellipsis,
text: TextSpan(text: match.preview, style: _base.copyWith(decoration: TextDecoration.lineThrough, color: tokens.globalTextMuted)),
),
RichText(
maxLines: 1,
overflow: TextOverflow.ellipsis,
text: TextSpan(text: after, style: _base.copyWith(color: tokens.globalFocus)),
),
],
);
}
}
class _ReplaceAllButton extends StatelessWidget {
const _ReplaceAllButton({required this.enabled, required this.tokens, required this.onTap});
final bool enabled;
final SurfaceTokens tokens;
final VoidCallback onTap;
@override
Widget build(BuildContext context) {
return Semantics(
button: true,
enabled: enabled,
label: 'Replace all',
child: ClideTappable(
onTap: enabled ? onTap : () {},
builder: (context, hovered, _) => Container(
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 5),
decoration: BoxDecoration(
color: enabled && hovered ? tokens.listItemHoverBackground : null,
border: Border.all(color: tokens.buttonBorder),
borderRadius: BorderRadius.circular(4),
),
child: ClideText(
'Replace all',
fontSize: clideFontCaption,
color: enabled ? tokens.sidebarForeground : tokens.globalTextMuted,
),
),
),
);
}
}
class _MessageDialog extends StatelessWidget {
const _MessageDialog({required this.title, required this.body, required this.dismiss});
final String title;
final String body;
final void Function([Object?]) dismiss;
@override
Widget build(BuildContext context) {
final tokens = ClideTheme.of(context).surface;
return _DialogFrame(
tokens: tokens,
children: [
ClideText(title, color: tokens.dropdownForeground),
const SizedBox(height: 8),
ClideText(body, fontSize: clideFontCaption, color: tokens.globalTextMuted),
const SizedBox(height: 12),
Align(
alignment: Alignment.centerRight,
child: _DialogButton(label: 'OK', tokens: tokens, onTap: () => dismiss()),
),
],
);
}
}
class _ConfirmDialog extends StatelessWidget {
const _ConfirmDialog({required this.body, required this.dismiss});
final String body;
final void Function([bool?]) dismiss;
@override
Widget build(BuildContext context) {
final tokens = ClideTheme.of(context).surface;
return _DialogFrame(
tokens: tokens,
children: [
ClideText(body, color: tokens.dropdownForeground),
const SizedBox(height: 12),
Row(
mainAxisAlignment: MainAxisAlignment.end,
children: [
_DialogButton(label: 'Cancel', tokens: tokens, onTap: () => dismiss(false)),
const SizedBox(width: 8),
_DialogButton(label: 'Confirm', tokens: tokens, onTap: () => dismiss(true)),
],
),
],
);
}
}
class _DialogFrame extends StatelessWidget {
const _DialogFrame({required this.tokens, required this.children});
final SurfaceTokens tokens;
final List<Widget> children;
@override
Widget build(BuildContext context) {
return Container(
width: 360,
padding: const EdgeInsets.all(16),
decoration: BoxDecoration(
color: tokens.dropdownBackground,
border: Border.all(color: tokens.modalSurfaceBorder),
borderRadius: BorderRadius.circular(6),
),
child: Column(mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.start, children: children),
);
}
}
class _DialogButton extends StatelessWidget {
const _DialogButton({required this.label, required this.tokens, required this.onTap});
final String label;
final SurfaceTokens tokens;
final VoidCallback onTap;
@override
Widget build(BuildContext context) {
return Semantics(
button: true,
label: label,
child: ClideTappable(
onTap: onTap,
builder: (context, hovered, _) => Container(
padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 5),
decoration: BoxDecoration(
color: hovered ? tokens.listItemHoverBackground : null,
border: Border.all(color: tokens.buttonBorder),
borderRadius: BorderRadius.circular(4),
),
child: ClideText(label, fontSize: clideFontCaption, color: tokens.sidebarForeground),
),
),
);
}
}
lib/src/daemon/search_commands.dart
+88
View File
@@ -11,12 +11,14 @@ import 'dart:async';
import 'dart:io';
import '../files/ignore.dart';
import '../files/path_safety.dart';
import '../ipc/command_schema.dart';
import '../ipc/envelope.dart';
import '../ipc/schema_v1.dart';
import '../panes/event_sink.dart';
import '../search/grep_engine.dart';
import '../search/match.dart';
import '../search/replace_engine.dart';
import 'dispatcher.dart';
/// Owns in-flight searches and streams their results onto the event
@@ -55,6 +57,50 @@ class SearchService {
_active.remove(id)?.cancel();
}
/// Compute (preview) or perform (apply) a search-and-replace.
///
/// Preview returns per-file before/after edits without touching disk.
/// Apply writes each changed file's new content through the workspace
/// path-safety guard. The clean-git-tree safety gate is enforced by
/// the caller (the UI checks `git.status` before requesting apply).
Future<Map<String, Object?>> replace(SearchQuery query, String replacement, {required bool apply}) async {
final files = await computeReplacements(
root: root,
ignore: ignore,
query: query,
replacement: replacement,
);
if (!apply) {
return {
'apply': false,
'files': [for (final f in files) f.toJson()],
'fileCount': files.length,
'totalCount': files.fold<int>(0, (s, f) => s + f.count),
};
}
final rootPath = root.absolute.path;
var changed = 0;
var total = 0;
for (final f in files) {
final newContent = rewriteFileContent(rootPath, f.path, query, replacement);
if (newContent == null) continue;
final String abs;
try {
abs = resolveUnderRootFollowingSymlinks(root, f.path);
} on PathOutsideRoot {
continue;
}
try {
File(abs).writeAsStringSync(newContent);
changed++;
total += f.count;
} catch (_) {
// skip unwritable files; the rest still apply
}
}
return {'apply': true, 'filesChanged': changed, 'totalCount': total};
}
Future<void> _run(String id, SearchQuery query, CancelToken cancel) async {
try {
await for (final batch in grepWorkspace(
@@ -101,6 +147,19 @@ const CommandSchema _grepSchema = CommandSchema(
},
);
const CommandSchema _replaceSchema = CommandSchema(
positional: ['pattern', 'replacement'],
args: {
'pattern': ArgSpec(required: true),
'replacement': ArgSpec(),
'regex': ArgSpec(type: ArgType.boolean),
'ignoreCase': ArgSpec(type: ArgType.boolean),
'include': ArgSpec(type: ArgType.stringList),
'exclude': ArgSpec(type: ArgType.stringList),
'apply': ArgSpec(type: ArgType.boolean),
},
);
void registerSearchCommands(DaemonDispatcher d, SearchService search) {
d.register('search.grep', (req) async {
final query = SearchQuery.fromJson(req.args);
@@ -118,6 +177,35 @@ void registerSearchCommands(DaemonDispatcher d, SearchService search) {
return IpcResponse.ok(id: req.id, data: {'searchId': id});
}, schema: _grepSchema);
d.register('search.replace', (req) async {
final query = SearchQuery.fromJson(req.args);
final replacement = (req.args['replacement'] as String?) ?? '';
final apply = req.args['apply'] == true;
if (query.pattern.isEmpty) {
return IpcResponse.err(
id: req.id,
error: IpcError(
code: IpcExitCode.userError,
kind: IpcErrorKind.userError,
message: 'search.replace requires a non-empty pattern',
),
);
}
try {
final result = await search.replace(query, replacement, apply: apply);
return IpcResponse.ok(id: req.id, data: result);
} on FormatException catch (e) {
return IpcResponse.err(
id: req.id,
error: IpcError(
code: IpcExitCode.userError,
kind: IpcErrorKind.userError,
message: 'invalid regex: ${e.message}',
),
);
}
}, schema: _replaceSchema);
d.register('search.cancel', (req) async {
final id = req.args['searchId'] as String?;
if (id == null || id.isEmpty) {
lib/src/search/replace_engine.dart
+187
View File
@@ -0,0 +1,187 @@
/// Workspace search-and-replace engine (T-53, per D-79).
///
/// Builds on the same query semantics as the grep engine: it walks the
/// ignore-pruned workspace, applies the replacement to each matching
/// file, and reports per-file, per-line before/after edits for preview.
/// The authoritative new file content is produced by applying the
/// replacement to the whole file; the per-line edits are derived with
/// the same logic so preview and apply never disagree.
///
/// Regex replacements support capture-group references (`$1`..`$9`,
/// `$&`/`$0` for the whole match, `$$` for a literal `$`).
library;
import 'dart:convert';
import 'dart:io';
import '../files/ignore.dart';
import '../files/listing.dart';
import 'match.dart';
/// One changed line within a file.
class ReplacementEdit {
const ReplacementEdit({required this.line, required this.before, required this.after});
final int line; // 1-based
final String before;
final String after;
Map<String, Object?> toJson() => {'line': line, 'before': before, 'after': after};
factory ReplacementEdit.fromJson(Map<String, Object?> j) => ReplacementEdit(
line: (j['line'] as num).toInt(),
before: j['before'] as String,
after: j['after'] as String,
);
}
/// The set of edits a replacement would make to one file.
class FileReplacement {
const FileReplacement({required this.path, required this.count, required this.edits});
final String path;
/// Number of individual matches replaced in the file.
final int count;
final List<ReplacementEdit> edits;
Map<String, Object?> toJson() => {
'path': path,
'count': count,
'edits': [for (final e in edits) e.toJson()],
};
factory FileReplacement.fromJson(Map<String, Object?> j) => FileReplacement(
path: j['path'] as String,
count: (j['count'] as num).toInt(),
edits: [
for (final e in (j['edits'] as List? ?? const []).whereType<Map>()) ReplacementEdit.fromJson(e.cast<String, Object?>()),
],
);
}
/// Apply [query]'s pattern to [text], substituting [replacement]. Returns
/// the rewritten text and the number of matches replaced.
({String text, int count}) applyToText(String text, SearchQuery query, String replacement) {
if (query.pattern.isEmpty) return (text: text, count: 0);
var count = 0;
final RegExp re;
if (query.regex) {
re = RegExp(query.pattern, caseSensitive: !query.ignoreCase);
} else {
re = RegExp(RegExp.escape(query.pattern), caseSensitive: !query.ignoreCase);
}
final out = text.replaceAllMapped(re, (m) {
count++;
return query.regex ? _expand(replacement, m) : replacement;
});
return (text: out, count: count);
}
/// Expand `$n` / `$&` / `$$` references in a regex replacement template.
String _expand(String template, Match m) {
final b = StringBuffer();
var i = 0;
while (i < template.length) {
final c = template[i];
if (c == r'$' && i + 1 < template.length) {
final next = template[i + 1];
if (next == r'$') {
b.write(r'$');
i += 2;
continue;
}
if (next == '&' || next == '0') {
b.write(m.group(0) ?? '');
i += 2;
continue;
}
if (_isDigit(next)) {
// Greedy two-digit group index when valid, else one digit.
var idx = int.parse(next);
var consumed = 2;
if (i + 2 < template.length && _isDigit(template[i + 2])) {
final two = int.parse('$next${template[i + 2]}');
if (two <= m.groupCount) {
idx = two;
consumed = 3;
}
}
if (idx <= m.groupCount) {
b.write(m.group(idx) ?? '');
i += consumed;
continue;
}
}
}
b.write(c);
i++;
}
return b.toString();
}
bool _isDigit(String s) => s.codeUnitAt(0) >= 0x30 && s.codeUnitAt(0) <= 0x39;
/// Compute the replacements [query] → [replacement] would make under
/// [root]. Returns one [FileReplacement] per changed file, with
/// per-line before/after edits for preview. Pure read-only — writing is
/// the caller's job (after the clean-tree safety gate).
Future<List<FileReplacement>> computeReplacements({
required Directory root,
required IgnoreSet ignore,
required SearchQuery query,
required String replacement,
int maxFiles = 5000,
}) async {
if (query.pattern.isEmpty) return const [];
if (query.regex) RegExp(query.pattern, caseSensitive: !query.ignoreCase); // validate
final walk = await walkFiles(root: root, ignore: ignore);
final rootPath = root.absolute.path;
final out = <FileReplacement>[];
for (final entry in walk.files) {
if (out.length >= maxFiles) break;
final fr = _replaceInFile(rootPath, entry.path, query, replacement);
if (fr != null) out.add(fr);
}
return out;
}
/// Compute the rewritten content for a single file, or null if the file
/// is binary/unreadable/unchanged. Exposed for the apply path + tests.
String? rewriteFileContent(String rootPath, String relPath, SearchQuery query, String replacement) {
final content = _readText('$rootPath/$relPath');
if (content == null) return null;
final r = applyToText(content, query, replacement);
if (r.count == 0) return null;
return r.text;
}
FileReplacement? _replaceInFile(String rootPath, String relPath, SearchQuery query, String replacement) {
final content = _readText('$rootPath/$relPath');
if (content == null) return null;
final whole = applyToText(content, query, replacement);
if (whole.count == 0) return null;
// Per-line preview edits, using the same apply logic line-by-line.
final edits = <ReplacementEdit>[];
var lineNo = 0;
for (final line in const LineSplitter().convert(content)) {
lineNo++;
final r = applyToText(line, query, replacement);
if (r.count > 0 && r.text != line) {
edits.add(ReplacementEdit(line: lineNo, before: line, after: r.text));
}
}
return FileReplacement(path: relPath, count: whole.count, edits: edits);
}
String? _readText(String absPath) {
try {
final bytes = File(absPath).readAsBytesSync();
final probe = bytes.length > 1024 ? bytes.sublist(0, 1024) : bytes;
if (probe.contains(0)) return null; // binary
return utf8.decode(bytes, allowMalformed: true);
} catch (_) {
return null;
}
}