private SemanticItem generateCurrentState(string[] inputTokens, Constraints inputConstraints)
{
var isValid = _parts.All(p => p.TryToValidate());
var totalLength = _parts.Select(p => p.CurrentLength).Sum();
if (!isValid || totalLength != inputTokens.Length)
{
return(null);
}
var constraints = inputConstraints;
for (var i = 0; i < _parts.Length; ++i)
{
constraints = _parts[i].Substitute(constraints);
}
return(_pattern.WithConstraints(constraints));
}
private bool executeCommand(SemanticItem command)
{
var priorQuestions = Db.CurrentLogRoot.GetQuestions();
var commandQuery = SemanticItem.AnswerQuery(Question.HowToDo, Constraints.WithInput(command));
var commandInterpretations = Db.SpanQuery(commandQuery).ToArray();
foreach (var interpretation in commandInterpretations)
{
if (executeCall(interpretation))
{
//we found a way how to execute the command
return(true);
}
}
var postQuestions = Db.CurrentLogRoot.GetQuestions();
var executionQuestions = postQuestions.Except(priorQuestions).ToArray();
_executionQuestions.AddRange(executionQuestions);
return(false);
}
internal Constraints FillContext(Constraints constraints)
{
var conditionValue = _isEnabled ? Name : "~ " + Name;
return(constraints.AddCondition(conditionValue));
}
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);
}
internal SemanticItem GetAnswer(string question, string input)
{
var query = SemanticItem.AnswerQuery(question, Constraints.WithInput(input));
return(EvaluationContext.Query(query).LastOrDefault());
}
internal void HandleEvent(string eventDescription)
{
Log.EventHandler(eventDescription);
var commands = Db.Query(SemanticItem.AnswerQuery(Question.WhatShouldAgentDoNow, Constraints.WithCondition(eventDescription))).ToArray();
foreach (var command in commands)
{
var result = ExecuteCommand(command.Answer);
/*if (!result)
* throw new NotImplementedException("Handle failed command");*/
}
}
private SemanticItem(string entity)
{
Question = V2.Question.Entity;
Answer = entity;
Constraints = new Constraints().AddValue(InputVar, this);
}
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);
}
private SemanticItem(string question, string answer, Constraints constraints)
{
Question = question;
Answer = answer;
Constraints = constraints;
}
internal static SemanticItem From(string question, string answer, Constraints constraints)
{
return(new SemanticItem(question, answer, constraints));
}
internal SemanticItem WithConstraints(Constraints constraints)
{
return(new SemanticItem(Question, Answer, constraints));
}
internal static SemanticItem Pattern(string patternValue, string question, string answer)
{
var constraints = new Constraints().AddInput(patternValue);
return(new SemanticItem(question, answer, constraints));
}
public static SemanticItem AnswerQuery(string question, Constraints constraints)
{
return(new SemanticItem(question, null, constraints));
}
