internal Constraints Substitute(Constraints constraints)
{
if (!containsVariables())
{
return(constraints);
}
var currentConstraints = constraints;
var currentOffset = _currentMatchStart;
for (var i = 0; i < _tokens.Count - 1; ++i)
{
var variable = _tokens[i];
var length = _variableLenghts[i];
var value = string.Join(" ", _input.Skip(currentOffset).Take(length));
var entityValue = SemanticItem.Entity(value);
currentOffset += length;
currentConstraints = currentConstraints.AddValue(variable, entityValue);
}
var lastValue = string.Join(" ", _input.Skip(currentOffset).Take(_currentMatchEnd - currentOffset));
var entityLastValue = SemanticItem.Entity(lastValue);
currentConstraints = currentConstraints.AddValue(_tokens.Last(), entityLastValue);
return(currentConstraints);
}
private SemanticItem _joinPhrases(EvaluationContext context)
{
var something1 = context.EvaluateOne("$something").Answer;
var something2 = context.EvaluateOne("$something2").Answer;
var joinedPhrase = something1 + " " + something2;
return(SemanticItem.Entity(joinedPhrase));
}
public Constraints AddValue(string variable, string value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
return(AddValue(variable, SemanticItem.Entity(value)));
}
internal SemanticItem EvaluateOne(string variable)
{
var many = Evaluate(variable);
if (many.Count() > 1)
{
throw new NotImplementedException();
}
return(many.FirstOrDefault() ?? SemanticItem.Entity(GetSubstitutionValue(variable)));
}
private SemanticItem encodeCall(string nativeActionId, List <Tuple <string, SemanticItem> > evaluatedValues)
{
var arguments = new Constraints();
foreach (var value in evaluatedValues)
{
arguments = arguments.AddValue(value.Item1, value.Item2);
}
return(SemanticItem.Entity(nativeActionId).WithConstraints(arguments));
}
internal SemanticItem ChooseOption(string question, IEnumerable <string> columns)
{
if (columns.Contains(_inputValue))
{
return(SemanticItem.Entity(_inputValue));
}
//TODO many strategies can be here
var result = EvaluationContext.Query(SemanticItem.AnswerQuery(question, Constraints.WithInput(_inputValue)));
return(result.FirstOrDefault());
}
internal EmptyAgent()
{
Body.Db.Container
.Pattern("when $condition then $action")
.HowToDo("add $action to trigger $condition")
.Pattern("no output is available")
.IsTrue("output is missing")
.Pattern("say $something")
.HowToDo("print $something")
.Pattern("ask $something")
.HowToDo("print $something joined with ?")
.Pattern("say $something and $something2")
.HowToDo("print $something joined with $something2")
.Pattern("user said $something")
.IsTrue("history contains $something")
.Pattern("you know $something")
.IsTrue("user said $something or $something is defined")
.Pattern(
"i think $something",
"a $something",
"an $something",
"maybe $something",
"probably $something",
"it is $something"
)
.HowToSimplify("$something")
.Pattern("it")
.HowToEvaluate("It", e =>
{
//TODO this is a simple workaround - allows to point to input only
return(SemanticItem.Entity(Body.InputHistory.Last()));
})
.Pattern("say $something instead of $something2")
.HowToDo("use $something instead of $something2 in output")
;
AddPolicy("when user input is received and it is a command then execute it");
AddPolicy("when output is missing then ask for help");
AddPolicy("when question was asked and user input can be an answer then fire event answer is provided");
AddPolicy("when answer is provided then accept the advice");
AddPolicy("when the last command failed and advice was received then repeat the last command");
}
internal Body()
{
Db.Container
.Pattern("print $something")
.HowToDo("Print", Db.Container.EvaluateCallArgsSpan("Print", _print, "$something"))
.Pattern("$something is a command")
.IsTrue("$something has how to do question specified")
.Pattern("the $something")
.HowToEvaluate("The", _the)
.Pattern("one")
.HowToConvertToNumber("1")
.Pattern("user input")
.HowToEvaluate("UserInput", _userInput)
.Pattern("history contains $something")
.IsTrue("HistoryContains", _historyContains)
.Pattern("write $value into $slot slot")
.HowToDo("WriteSlot", Db.Container.EvaluateCallArgsSpan("WriteSlot", _writeSlot, "$value", "$slot"))
.Pattern("$slot slot is filled")
.IsTrue("IsSlotFilled", _isSlotFilled)
.Pattern("use $replacement instead of $pattern in output")
.HowToDo("OutputChanger", _outputChanger)
.Pattern("$something can be an answer")
.IsTrue("CanBeAnswer", e =>
{
var result = e.Query("$something", Question.CanItBeAnswer).FirstOrDefault();
var canBeAnswer = result == null || result.Answer == Database.YesAnswer;
return(canBeAnswer ? SemanticItem.Yes : SemanticItem.No);
})
.Pattern("execute $something")
.HowToDo("Execute", e =>
{
var something = e.EvaluateOne("$something");
return(something);
})
.Pattern("~ $something")
.IsTrue("Not", _notCond)
.Pattern("$value1 or $value2")
.IsTrue("Or", _orCond)
.Pattern("$action1 and $action2")
.HowToDo("And", _and)
.Pattern("$value1 and $value2")
.IsTrue("And", _andCond)
.Pattern("$something has $question question specified")
.IsTrue("IsQuestionSpecified", e =>
{
var something = e.EvaluateOne("$something");
var question = e.GetSubstitutionValue("$question");
var normalizedQuestion = question + " $@ ?";
var queryItem = SemanticItem.AnswerQuery(normalizedQuestion, Constraints.WithInput(something.Answer));
var result = Db.Query(queryItem);
var answer = result.Any() ? Database.YesAnswer : Database.NoAnswer;
return(SemanticItem.Entity(answer));
})
.Pattern("add $action to trigger $trigger")
.HowToDo("TriggerAdd", _triggerAdd)
.Pattern("fire event $event")
.HowToDo("FireEvent", _fireEvent)
.Pattern("$something joined with $something2")
.HowToEvaluate("JoinPhrases", _joinPhrases)
.Pattern("dump database")
.HowToDo("DumpDatabase", c =>
{
Log.Dump(Db);
Print("ok");
return(true);
})
;
_commandControl = new CommandControlModule(this);
_adviceModule = new AdviceModule(this);
AddModule(_commandControl);
AddModule(_adviceModule);
}
private SemanticItem _userInput(EvaluationContext context)
{
return(SemanticItem.Entity(_inputHistory.Last()));
}
internal bool ExecuteCommand(string utterance)
{
return(executeCommand(SemanticItem.Entity(utterance)));
}
private IEnumerable <SemanticItem> fetchMatchingEntries(SemanticItem queryItem)
{
if (queryItem.Question == null)
{
throw new NotImplementedException();
}
if (queryItem.Answer != null)
{
throw new NotImplementedException();
}
var result = new List <SemanticItem>();
if (queryItem.Question == Question.IsItTrue)
{
//TODO conditions should be more general thing
var inputConditions = new HashSet <string>(queryItem.Constraints.Conditions);
var condition = queryItem.InstantiateInputWithEntityVariables();
logDependency(condition);
if (inputConditions.Contains(condition))
{
//condition is met because of input
result.Add(SemanticItem.Entity(YesAnswer));
}
var negatedCondition = Constraints.Negate(condition);
if (inputConditions.Contains(negatedCondition))
{
//we have got a negative result
result.Add(SemanticItem.Entity(NoAnswer));
}
}
if (result.Count > 0)
{
return(result);
}
foreach (var item in GetData())
{
if (item.Question != queryItem.Question)
{
continue;
}
/*if ((item.Constraints.Input == null) != (queryItem.Constraints == null))
* //when input is provided it should be considered
* continue;*/
if (item.Constraints.Input != null)
{
var matcher = new InputMatcher();
var itemMatches = matcher.Match(item, queryItem).ToArray();
var matchedItems = new List <SemanticItem>();
foreach (var match in itemMatches)
{
if (meetConditions(queryItem, match))
{
matchedItems.Add(match);
}
}
result.AddRange(matchedItems.OrderByDescending(i => rank(i)));
}
else
{
if (meetConditions(queryItem, item))
{
result.Add(item);
}
}
if (result.Count > 0)
{
break;
}
}
return(result);
}
