425 karma · joined February 22, 2012
You can use floating window or sidepanel also for the agent. New tab is just for convenience.
So it does the first pass (based on your goals) makes memories (and these are local)
Now you tell the agent you want to do this repeatedly, so it will make a workflow (these workflows are saved on server, currently all public for now but we are working out permissions/group based access) for you based on these memories and interactions.
The problem is many times that the agent thinks is stable isn't really, so there a feedback loop for the agent to test out the workflow and improve them. (its basically claude code/codex sitting in the browser)
Workflow details are appended to prompt based on user query match/opened tabs match.
Self healing css selectors is also only 1 part of the story. The other part is the cohesive interface for the agent itself to use these selectors.
https://medium.com/@012parth/what-source-code-is-worth-study...
> Can you provide any form of demonstration of an LLM reading these files and acting accordingly
claude does update them at the end of the session (i say wrap up on prompt). the ones you are seeing in that gist are original forms, they evolve with each commit.
https://gist.github.com/artpar/60a3c1edfe752450e21547898e801...
(specially the AGENT.knowledge is quite helpful)
Fairly readable and doesn't seem wrong ( havent gone in depth yet)
[0] https://github.com/robertkrimen/otto [1] https://github.com/daptin/daptin [2] https://daptin.github.io/docs/actions/actions/
https://github.com/artpar/gosax/
its a High performance golang implementation of Symbolic Aggregate approXimation
unlogged-sdk => generates binary logs of code execution
unlogged intellij plugin => method level history, replay at method level, generate test cases
But you will have to create the instances of your target class object (plus all of its dependencies) which is going to be really cumbersome.
Consider a Spring service class which uses another redis service and a database service and you want to call a method on this service. So now you have to create the redis service first (copy/paste their config values etc), then the database service and then the actual spring service you want to test.
Once you have created the service, now you need to create the parameter values required by your target method, which you would either create using a new Xyz(), variable.setX, setY and so on, or alternatively now try to import a JSON mapper (ok so now we need to add the classpath to the dependencies as well), and then reconstruct the parameter with objectMapper.readValueAsString("{json here}", Xyz.class);
You can see how this gets unnecessarily complicated depending on the project you are working with.
So with direct invoke you have all the class instances ready in the correct state and you can just call a function. The service classes are being setup by your start up procedure anyways. And for the parameters we are currently using the objectMapper approach so its all setup and ready to use.
I encourage you to give this a try, surely this should be less context switching if you are using intellij as your ide.
We have still have that in the plugin. If you are interested I can share a custom build with that enabled for you to try it out. Just send me an email or ping us on the discord group.
We also have a boilerplate test case generator which uses dummy values, and this one you can use even without using the java agent. Its the first tab you will see in the plugin window after installing.
There is definitely nothing wrong with it if there are unit test cases available. But there is some extent of context switching in the current code-test cycle. And in the worst case scenario there are no test cases altogether and the team would rely on sanity testing + qa testing, eventually leading to some regressions on production. So you would be able to do the same thing with Atomic Run which you are doing currently with junit test cases but faster.
> Isn't this just reinventing the wheel and just replicating a built in IDE feature?
There is an overlap of functionality but no reinventing of wheel for sure. What we are trying to invent is construction of test cases itself without them being in the form of a junit test case (which is a maintenance overhead)
> Also this is seems to be unit testing, E2E (or to be precise "component") testing in my experience is what takes much longer and is where time is lost constructing the fixtures, but importantly E2E tells you if you've made stupid mistakes like using GET instead of POST, or have an XML serialiser overriding the JSON one you intended, which you don't pick up in unit tests.
So this is actually E2E testing and not unit testing because we don't have the capability of mocking down stream calls. If you do a Atomic Run on method1 which calls method2 and method3 on a different service, the method2/method3 would still be invoked and the outcome would depend on their response. Once we have the downstream mocking ready then it would be a unit test.
> Now if you could somehow save an entire VM stack/state of a system for E2E tests that wasn't brittle to code change, that could just rebuild that state with a single line of code, that would be my dream time saver. The closest I've seen anything like that is recording HTTP request responses or serialising individual Java objects to JSON and using those as fixtures...
Believe me this is what we started doing in the first place, and we have still have that in the plugin. It is just hidden from the UI since we received a mediocre response on generating junit test cases (maintenance headache). So we trimmed it down to the current form. If you are interested I can share a custom build with that enabled for you to try it out. Just send me an email or ping us on the discord group.
About android, just want to point out that our current builds are not compatible with android since dalvik has different ways of working (register based) compared to desktop jvms (stack based)
The only difference which I am thinking here is (based on just their front page), seems they are recording only function parameters and return values. If that understanding is correct, videobug is recording down to local variable level data (so lets say if you return a list from a db query and iterate over it in your business logic function, you will be able to see execution inside the loop.
Also, in the FAQ, it says the pre-production/production env is likely to be years away. While we are very early, we are definitely aiming videobug in pre-production to begin with.