430 lines
12 KiB
Dart
430 lines
12 KiB
Dart
import 'package:flutter/services.dart';
|
|
import 'package:intl/intl.dart';
|
|
|
|
/// Represents a parsed prompt variable.
|
|
///
|
|
/// Variables can be either system variables (auto-resolved) or custom input
|
|
/// variables (require user input).
|
|
///
|
|
/// Syntax: `{{variable_name}}` or `{{variable_name | type:property=value}}`
|
|
class PromptVariable {
|
|
const PromptVariable({
|
|
required this.fullMatch,
|
|
required this.name,
|
|
required this.type,
|
|
required this.properties,
|
|
required this.start,
|
|
required this.end,
|
|
});
|
|
|
|
/// The full matched string including `{{` and `}}`.
|
|
final String fullMatch;
|
|
|
|
/// The variable name (e.g., "description", "CURRENT_DATE").
|
|
final String name;
|
|
|
|
/// The input type (e.g., "text", "textarea", "select", "number").
|
|
/// Null for simple variables without type specification.
|
|
final PromptVariableType type;
|
|
|
|
/// Additional properties like placeholder, default, required, options.
|
|
final Map<String, String> properties;
|
|
|
|
/// Start index of the match in the original string.
|
|
final int start;
|
|
|
|
/// End index of the match in the original string.
|
|
final int end;
|
|
|
|
/// Whether this variable requires user input.
|
|
bool get requiresUserInput => !isSystemVariable;
|
|
|
|
/// Whether this is a system variable that can be auto-resolved.
|
|
bool get isSystemVariable {
|
|
final upper = name.toUpperCase();
|
|
return _systemVariableNames.contains(upper);
|
|
}
|
|
|
|
/// Whether this field is marked as required.
|
|
bool get isRequired => properties['required'] == 'true';
|
|
|
|
/// Get the placeholder text, if specified.
|
|
String? get placeholder => properties['placeholder'];
|
|
|
|
/// Get the default value, if specified.
|
|
String? get defaultValue => properties['default'];
|
|
|
|
/// Get min value for number inputs.
|
|
double? get min {
|
|
final val = properties['min'];
|
|
return val != null ? double.tryParse(val) : null;
|
|
}
|
|
|
|
/// Get max value for number inputs.
|
|
double? get max {
|
|
final val = properties['max'];
|
|
return val != null ? double.tryParse(val) : null;
|
|
}
|
|
|
|
/// Get step value for number inputs.
|
|
double? get step {
|
|
final val = properties['step'];
|
|
return val != null ? double.tryParse(val) : null;
|
|
}
|
|
|
|
/// Get options for select inputs.
|
|
List<String> get options {
|
|
final optionsStr = properties['options'];
|
|
if (optionsStr == null) return const [];
|
|
// Parse JSON array format: ["Option1","Option2"]
|
|
final trimmed = optionsStr.trim();
|
|
if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) return const [];
|
|
final inner = trimmed.substring(1, trimmed.length - 1);
|
|
if (inner.isEmpty) return const [];
|
|
return inner
|
|
.split(',')
|
|
.map((s) => s.trim())
|
|
.map((s) {
|
|
// Remove surrounding quotes
|
|
if ((s.startsWith('"') && s.endsWith('"')) ||
|
|
(s.startsWith("'") && s.endsWith("'"))) {
|
|
return s.substring(1, s.length - 1);
|
|
}
|
|
return s;
|
|
})
|
|
.where((s) => s.isNotEmpty)
|
|
.toList();
|
|
}
|
|
|
|
/// Display label for the variable (formatted from name).
|
|
String get displayLabel {
|
|
// Convert snake_case or camelCase to Title Case
|
|
final words = name
|
|
.replaceAllMapped(
|
|
RegExp(r'([a-z])([A-Z])'),
|
|
(m) => '${m.group(1)} ${m.group(2)}',
|
|
)
|
|
.replaceAll('_', ' ')
|
|
.split(' ')
|
|
.map(
|
|
(w) => w.isNotEmpty
|
|
? '${w[0].toUpperCase()}${w.substring(1).toLowerCase()}'
|
|
: '',
|
|
)
|
|
.join(' ');
|
|
return words;
|
|
}
|
|
|
|
static const Set<String> _systemVariableNames = {
|
|
'CLIPBOARD',
|
|
'CURRENT_DATE',
|
|
'CURRENT_DATETIME',
|
|
'CURRENT_TIME',
|
|
'CURRENT_TIMEZONE',
|
|
'CURRENT_WEEKDAY',
|
|
'USER_NAME',
|
|
'USER_LANGUAGE',
|
|
'USER_LOCATION',
|
|
};
|
|
}
|
|
|
|
/// Types of prompt variable inputs.
|
|
enum PromptVariableType {
|
|
/// Simple text input (single line).
|
|
text,
|
|
|
|
/// Multi-line text input.
|
|
textarea,
|
|
|
|
/// Dropdown select.
|
|
select,
|
|
|
|
/// Number input.
|
|
number,
|
|
}
|
|
|
|
/// Parses prompt content to extract variables.
|
|
class PromptVariableParser {
|
|
const PromptVariableParser();
|
|
|
|
/// Regular expression to match prompt variables.
|
|
/// Matches: {{variable_name}} or {{variable_name | type:prop=value:prop2=value2}}
|
|
static final _variablePattern = RegExp(
|
|
r'\{\{([^{}|]+?)(?:\s*\|\s*([^{}]+?))?\}\}',
|
|
multiLine: true,
|
|
);
|
|
|
|
/// Parse all variables from prompt content.
|
|
List<PromptVariable> parse(String content) {
|
|
final variables = <PromptVariable>[];
|
|
final matches = _variablePattern.allMatches(content);
|
|
|
|
for (final match in matches) {
|
|
final fullMatch = match.group(0)!;
|
|
final name = match.group(1)!.trim();
|
|
final typeAndProps = match.group(2)?.trim();
|
|
|
|
var type = PromptVariableType.text;
|
|
final properties = <String, String>{};
|
|
|
|
if (typeAndProps != null && typeAndProps.isNotEmpty) {
|
|
// Parse type and properties: type:prop1=value1:prop2=value2
|
|
final parts = _parseTypeAndProperties(typeAndProps);
|
|
type = parts.type;
|
|
properties.addAll(parts.properties);
|
|
}
|
|
|
|
variables.add(
|
|
PromptVariable(
|
|
fullMatch: fullMatch,
|
|
name: name,
|
|
type: type,
|
|
properties: properties,
|
|
start: match.start,
|
|
end: match.end,
|
|
),
|
|
);
|
|
}
|
|
|
|
return variables;
|
|
}
|
|
|
|
/// Parse type and properties from the part after `|`.
|
|
_TypeAndProperties _parseTypeAndProperties(String input) {
|
|
var type = PromptVariableType.text;
|
|
final properties = <String, String>{};
|
|
|
|
// Split by `:` but handle nested structures like options=["a","b"]
|
|
final segments = _splitProperties(input);
|
|
|
|
for (var i = 0; i < segments.length; i++) {
|
|
final segment = segments[i].trim();
|
|
if (segment.isEmpty) continue;
|
|
|
|
if (i == 0 && !segment.contains('=')) {
|
|
// First segment without = is the type
|
|
type = _parseType(segment);
|
|
} else if (segment.contains('=')) {
|
|
// Property=value pair
|
|
final eqIndex = segment.indexOf('=');
|
|
final key = segment.substring(0, eqIndex).trim().toLowerCase();
|
|
final value = segment.substring(eqIndex + 1).trim();
|
|
properties[key] = value;
|
|
} else if (segment.toLowerCase() == 'required') {
|
|
// Boolean flag
|
|
properties['required'] = 'true';
|
|
}
|
|
}
|
|
|
|
return _TypeAndProperties(type: type, properties: properties);
|
|
}
|
|
|
|
/// Split properties while respecting brackets.
|
|
List<String> _splitProperties(String input) {
|
|
final segments = <String>[];
|
|
var current = StringBuffer();
|
|
var bracketDepth = 0;
|
|
var inQuotes = false;
|
|
String? quoteChar;
|
|
|
|
for (var i = 0; i < input.length; i++) {
|
|
final char = input[i];
|
|
|
|
if (inQuotes) {
|
|
current.write(char);
|
|
if (char == quoteChar && (i == 0 || input[i - 1] != r'\')) {
|
|
inQuotes = false;
|
|
quoteChar = null;
|
|
}
|
|
} else if (char == '"' || char == "'") {
|
|
inQuotes = true;
|
|
quoteChar = char;
|
|
current.write(char);
|
|
} else if (char == '[' || char == '{' || char == '(') {
|
|
bracketDepth++;
|
|
current.write(char);
|
|
} else if (char == ']' || char == '}' || char == ')') {
|
|
bracketDepth--;
|
|
current.write(char);
|
|
} else if (char == ':' && bracketDepth == 0) {
|
|
segments.add(current.toString());
|
|
current = StringBuffer();
|
|
} else {
|
|
current.write(char);
|
|
}
|
|
}
|
|
|
|
if (current.isNotEmpty) {
|
|
segments.add(current.toString());
|
|
}
|
|
|
|
return segments;
|
|
}
|
|
|
|
PromptVariableType _parseType(String typeStr) {
|
|
switch (typeStr.toLowerCase()) {
|
|
case 'textarea':
|
|
return PromptVariableType.textarea;
|
|
case 'select':
|
|
return PromptVariableType.select;
|
|
case 'number':
|
|
return PromptVariableType.number;
|
|
case 'text':
|
|
default:
|
|
return PromptVariableType.text;
|
|
}
|
|
}
|
|
|
|
/// Check if content has any variables that require user input.
|
|
bool hasUserInputVariables(String content) {
|
|
final variables = parse(content);
|
|
return variables.any((v) => v.requiresUserInput);
|
|
}
|
|
|
|
/// Check if content has any variables (system or user input).
|
|
bool hasVariables(String content) {
|
|
return _variablePattern.hasMatch(content);
|
|
}
|
|
}
|
|
|
|
class _TypeAndProperties {
|
|
const _TypeAndProperties({required this.type, required this.properties});
|
|
|
|
final PromptVariableType type;
|
|
final Map<String, String> properties;
|
|
}
|
|
|
|
/// Resolves system variables to their actual values.
|
|
class SystemVariableResolver {
|
|
const SystemVariableResolver({
|
|
this.userName,
|
|
this.userLanguage,
|
|
this.userLocation,
|
|
});
|
|
|
|
final String? userName;
|
|
final String? userLanguage;
|
|
final String? userLocation;
|
|
|
|
/// Resolve a system variable to its value.
|
|
/// Returns null if the variable cannot be resolved.
|
|
Future<String?> resolve(String variableName) async {
|
|
final upper = variableName.toUpperCase();
|
|
|
|
switch (upper) {
|
|
case 'CLIPBOARD':
|
|
return _getClipboard();
|
|
case 'CURRENT_DATE':
|
|
return DateFormat.yMMMd().format(DateTime.now());
|
|
case 'CURRENT_DATETIME':
|
|
return DateFormat.yMMMd().add_jm().format(DateTime.now());
|
|
case 'CURRENT_TIME':
|
|
return DateFormat.jm().format(DateTime.now());
|
|
case 'CURRENT_TIMEZONE':
|
|
return DateTime.now().timeZoneName;
|
|
case 'CURRENT_WEEKDAY':
|
|
return DateFormat.EEEE().format(DateTime.now());
|
|
case 'USER_NAME':
|
|
return userName ?? '';
|
|
case 'USER_LANGUAGE':
|
|
return userLanguage ?? '';
|
|
case 'USER_LOCATION':
|
|
return userLocation ?? '';
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Future<String?> _getClipboard() async {
|
|
try {
|
|
final data = await Clipboard.getData(Clipboard.kTextPlain);
|
|
return data?.text ?? '';
|
|
} catch (_) {
|
|
return '';
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Result of processing a prompt with variables.
|
|
class ProcessedPrompt {
|
|
const ProcessedPrompt({
|
|
required this.content,
|
|
required this.userInputVariables,
|
|
});
|
|
|
|
/// The prompt content with system variables already resolved.
|
|
final String content;
|
|
|
|
/// Variables that still require user input.
|
|
final List<PromptVariable> userInputVariables;
|
|
|
|
/// Whether user input is still needed.
|
|
bool get needsUserInput => userInputVariables.isNotEmpty;
|
|
}
|
|
|
|
/// Processes prompt content by resolving system variables and identifying
|
|
/// user input variables.
|
|
class PromptProcessor {
|
|
const PromptProcessor({required this.parser, required this.systemResolver});
|
|
|
|
final PromptVariableParser parser;
|
|
final SystemVariableResolver systemResolver;
|
|
|
|
/// Process prompt content.
|
|
///
|
|
/// Returns a [ProcessedPrompt] with system variables resolved and
|
|
/// a list of variables that need user input.
|
|
Future<ProcessedPrompt> process(String content) async {
|
|
final variables = parser.parse(content);
|
|
if (variables.isEmpty) {
|
|
return ProcessedPrompt(content: content, userInputVariables: const []);
|
|
}
|
|
|
|
var processedContent = content;
|
|
final userInputVars = <PromptVariable>[];
|
|
|
|
// Process variables in reverse order to preserve indices
|
|
for (final variable in variables.reversed) {
|
|
if (variable.isSystemVariable) {
|
|
final resolved = await systemResolver.resolve(variable.name);
|
|
if (resolved != null) {
|
|
processedContent = processedContent.replaceRange(
|
|
variable.start,
|
|
variable.end,
|
|
resolved,
|
|
);
|
|
}
|
|
} else {
|
|
userInputVars.insert(0, variable);
|
|
}
|
|
}
|
|
|
|
return ProcessedPrompt(
|
|
content: processedContent,
|
|
userInputVariables: userInputVars,
|
|
);
|
|
}
|
|
|
|
/// Apply user-provided values to the processed content.
|
|
String applyUserValues(String content, Map<String, String> values) {
|
|
final variables = parser.parse(content);
|
|
if (variables.isEmpty) return content;
|
|
|
|
var result = content;
|
|
|
|
// Apply in reverse order to preserve indices
|
|
for (final variable in variables.reversed) {
|
|
if (!variable.isSystemVariable && values.containsKey(variable.name)) {
|
|
result = result.replaceRange(
|
|
variable.start,
|
|
variable.end,
|
|
values[variable.name]!,
|
|
);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|