| Age | Commit message (Collapse) | Author |
|---|
|
Contra d2edf150cf2c876971383a4a484f289ce7e7f680, this module is the one place
that I do need the stupid __main__ thing.
|
|
Like the previous commit, this matches Omni/Test.hs.
|
|
This matches Omni/App.hs, and I'll use it in future projects.
|
|
Apparently the driSupport is no longer needed, so I had to delete that. Anyway
moving the Docker dev stuff to a centralized file should be helpful and ensure
that it continues to work the same way across systems.
|
|
I read that this was desired for nvidia stuff, so I enabled it. Not sure if its
necessary but it doesn't hurt anything I guess.
|
|
This should have been done before as it only pertains to Lithium.
|
|
Slowly moving everything to this domain, it will take a while though.
|
|
I realized I don't need this stupid `__main__` convention anymore because my
build system always calls Python programs like `python -m main`, so I just need
to have a function named `main()`. I also started adding some general coding
conventions to the README and fixed a typo.
|
|
This replaces the manually-curated nixTargets list in Bild.hs. Now any nix file
that has the executable bit set will be built.
I added run.sh shebangs to each of the buildable nix targets as well. When
executing these, they will succeed at building, but they have no 'out' metadata,
and so when run.sh tries to exec them, it will fail. This is fine for now.
How would one go about execing a linux tree anyway? If all of the nix targets
output something standard like a qemu image or a container, then I could have a
standard wrapper that calls the image and starts the system. That might be the
ideal way to have a runnable nix target. But this would require rethinking my
infrastructure and how to deploy things, so I can't quite do that yet.
|
|
I often want to view gitstats but I always forget how to generate and view them,
so this script simply captures this workflow and tests that it continues to
work.
|
|
This was previously implemented in c467f7611f66b6d9b9dcb589ed534374cd7b2e6c but
got lost when I updated nixos at some point. And then I noticed ClaudeBot was
crawling my code while I was working on the previous commit. I don't really like
that, so I'll just add this noindex and see if it stops.
|
|
After the update, the /git endpoint was redirecting in circles and I couldn't
figure out why. Eventually I just moved it to a subdomain, and in the process I
found out that the git-daemon thing doesn't work anymore because of the user
ownership of the repos, as mentioned in the long comment. So I just disabled
that. Now it works, but cloning is only available over ssh, and that's fine I
guess.
|
|
The problem was that the ssl cert wasn't renewing. I added the domains to the
nginx config, and cleaned up some other stuff. During debug I also udpated
nixos-mailserver and nixos stable because I thought it would fix something; it
didn't but I might as well use the updated versions of stuff since it seems to
still work fine.
|
|
I mostly wanted a formatter that would format `inherit` blocks
vertically, because otherwise they are super hard to read when diffing
or even just editing. Both alejandra and the new nixos/nixfmt format
verically like this, but alejandra has slightly better format (I guess)
and for some reason nixfmt did not respect my `GLOBIGNORE` setting when
doing `nixfmt **/*.nix` so it was trying to format stuff in `_/nix`, and
failed. So anyway I went with alejandra.
- https://github.com/kamadorueda/alejandra
- https://discourse.nixos.org/t/enforcing-nix-formatting-in-nixpkgs/49506
|
|
It's good to update, I think nixos 24.05 was deprecated anyway. The iPython
dontCheck is because there was a test timeout; I don't even know why iPython is
being pulled in but whatever.
|
|
With run.sh, we can build and run the file in one go. This means we can also use
it as an interpreter in a shebang line and properly use the Unix executable bit.
This is pretty cool and gives a few advantages: running any executable file is
just `exec file.hs` or even `./file.hs`, finding all executables is `fd -t x`,
you don't need to specify or know an `out` name to run something, execution of a
program is standardized.
There is a hack to get this to work. In C and Common Lisp, `#!` is illegal
syntax, so I had to use shell syntax to invoke run.sh, call it on the current
file, and then exit the shell script. Meanwhile, run.sh takes the file and evals
the whole thing, building and running it. As long as either `//` or `;` is a
comment character in the target language, then this works. Maybe a better thing
to do would be to pre-process the file and remove the `#!` before passing it to
the C compiler, like [ryanmjacobs/c][1] and [tcc][2]? However this won't work in
Lisp because then I can't just load the file directly into the repl, so maybe
the comment hack needs to stay.
[1]: https://github.com/ryanmjacobs/c/tree/master
[2]: https://repo.or.cz/tinycc.git/blob/HEAD:/tccrun.c
|
|
I put the storybook into a new Biz.nix deploy target. The idea here is that any
Biz/* targets should be hosted by this one VM for simplicity. Over time I can
grow this as need be, but this should work to host a few services.
|
|
I need a way to reliably get a NixOS VM provisioned in the cloud, and the
easiest way to do this is to create a qcow2 image, upload it to Digital Ocean,
and use that to start a droplet. This is very much a manual process, but that's
fine, I shouldn't need to do it very often (for now).
|
|
This adds the Images endpoint and related functions for loading and saving
images to the filesystem.
In the view layer, it also loads the images asynchronously using HTMX, so the
images get lazy-loaded only when they are done generating.
|
|
This was all dead weight, just delete it and move on.
|
|
This is basically a full rewrite. I ripped out Flask and rearchitected the whole
thing to use fully RESTful resources and endpoints using Ludic. The UI was
completely redone to use Ludic's components. I added tests for everything that I
reasonably could.
This is almost ready for an alpha launch. Before shipping it I still need to:
1. generate images using image n-1 applied to `openai.images.create_variation()`
2. write a nix service, get it on a VM somewhere, I'll probably provision a new
VM for this
3. replace the `db` thing with a real sqlite database
I only need the first one done to show it to Lia and see if she likes it, that
should be completed in a day or two. Then the nix service and deployment won't
take long at all. Setting up a sqlite database will be annoying, but that I
can't see that actually taking more than 2 days. So max 5 days out from
launching this to friends and family.
|
|
This required upgrading to python 3.12 because of some f-string format thing
that ludic uses. It's kind of annoying but the upgrade was easy enough, so I
just did it.
|
|
It's good to do this often.
|
|
This paritally used gptme to create a storybook generator. The problem I ran
into is that gptme doesn't do any architecting or considerations for
maintainable code, or even readable code, so it just wrote a long script. I
couldn't test it. Also, it didn't actually generate a 10-page story, it
generated 10 separate stories. So, I ended up writing it myself and using gptme
to fixup TODOs that I wrote along the way.
|
|
I had forgotten to add this feature, apparently, so bild --test just didn't do
the test part.
|
|
This is handy for looking at llm chat history.
|
|
I forgot to add llm to this, instead I just added the extra libraries, which
meant I had the libraries present but not the binary for running them! And llm
is important in the base dev environment because I need to experiment with the
various llms independent of my application code.
|
|
I was getting confused about what is a product and what is internal
infrastructure; I think it is good to keep those things separate. So I moved a
bunch of stuff to an Omni namespace, actually most stuff went there. Only things
that are explicitly external products are still in the Biz namespace.
|
