New Tuesday - new project

The resume-builder software is doing great.  I can expand on it, but it allowed me to cover off a few new skills as well as keeping old ones current:

Skills

1.  LaTeX templates with Jinja2 - allows for flexible and custom output in a very clean, academic appearing format.
2. Conversion of resume from .doc to .yml - now the resume is data.  It can be easily read in, manipulated, and modified at production time.
3.  Introducing more ollama!  
4.  Fierce testing with pytest and more fixture fun!

It's NEW!

I have toyed with this project for some time: a good idea/bad idea system to bounce ideas off another being to contemplate ideas that cross my plate.

The idea is to accept input from a user in the form of text such as: "I really enjoy sunsets but my neighbour's house is in the way - I want to burn it down."

Immediately, we would all agree that it's a bad idea.  What I want to see is the reaction and comments from multiple sources and then amalgamate those into a single response.

Currently, the basics are there - the ollama stuff, the spinning up of new prompt instances using the Jungian Archetypes as those to bounce ideas off of.

• Magician
• Sage
• Sovereign
• Hero
• Rebel
• Everyman
• Creator
• Explorer
• Caregiver
• Lover
• Jester
• Innocent

  Sample input:  

 
 
sample_idea = (
        """I really love sunsets.  My neighbour's house is in the way. I wish to
        burn down their house so I can enjoy the sunsets more."""
    )

 Sample output:

 

So of course, the next step is to:

WRITE ALL THE TESTS THAT WE DON'T HAVE NOW!!!

 

Coverage, and more changes.

I omitted the tests folder from considered in the test coverage.  It drops down to 71%.  I might spend the next 30 minutes to bring that up a bit but I don't want to expend too much more effort.  I have enough functionality being covered off for adding more.

Bringing app2.py might be wise.

With some mocking, (thanks unittest.mock's patch), The coverage is up to 82% as shown below.  I learned a lot with being able to call directly into my Flask application.  This is a good reason to celebrate!

 

Refactoring is good.

The code is cleaner - a flat file with some really haphazardly written code is now in smaller, manageable methods, and existing test cases are passing.  Next, it's going to be all about showing the resume in the browser, and having an accept/reject button for it.

The alert box wasn't coming up - fixed that with a simple change out.

 

Post Thanksgiving Blues

And so the day starts again, clean slate w.r.t. git, test cases, and now time to mess with things to bring a simple stand alone Flask application into doing more things.

  

Renderer

Renderer needs to be put in a class so not only can it be easily tested, but also more manageable for the future.

It is comprised of some standalone functions to deal with cleaning ampersands from the text, and a huge monolithic function called: build_resume.

It really should be renamed as render_resume. 

Moved it into a class now and writing up additional test cases for going forward as I develop it.

Coverage

 

Enhanced coverage so I'm reasonably happy with the progress - the test did manage to push things further along with a flaw in the design.

 

 

 

Success!

All tests are passing, code is cleaned up!

 

The basic functionality does seem to be working despite some bodged together code.  The verbosity does seem to be working properly and the output is in the jobs/<company-name> folder.

The modified .yml file is not being populated but left as a stub for now. 

More Test Cases for Ba'al!

The refactoring is slow right now - seriously I need more test cases in place before I do the next stage.

This way, if I make a mistake, I'll know it first hand.

I just found one bug that needs to be fixed for making the code testable.  Yay.

Almost through the flow

Just have to explore the cases of accepting/denying and checking if that logic works or not for pass/fail cases.

Then.  And only then, can the next round of functional improvements can begin.

It's all good.

 

Yikes!  Failures!  But to be honest, this is a good thing.  When testing, failures means that something needs to be fixed.

Instead of just letting a system die, it's time to fix things.  Otherwise, it's just giving up or what we used to call: Windows 3.0.

Yes, there is a reference to Tidy Bowl.  Product Function: It uses blue or lavender liquids and tablets placed inside the toilet tank to fight hard water stains, mineral buildup, and ring formation between regular scrubbings.  It was also marketed as Ty-D-Bol (sounds like the topic for a podcast).

I use it as my example of a job that I would not be good at:

Company: TidyBowl (avoids messy trademarking stuff)

Role: Taste Tester

Job Description: Must have excellent taste testing skills.   A sommelier for boxed wine.

This job, like boxed wines does not pair well with my skills, typically earning a 0 score, and None for a created cover letter.  A zero score should also invalidate the button to produce output.  The only option is to return to the system.

The 3 errors were introduced with some changes to the selenium (automated UI) tests.  The fourth is a dangling error from earlier that is proving to be annoying to fix at this time.

Much better

 

The fix was simple: a breakpoint() call while I was debugging the verbosity field coming back in the request.form.  Done and dusted - back to coding the flow tests and the actual flow code.

Pieces are coming together

The pieces are coming together.  Yay!

Refactor day

Okay - first before refactoring happens, more test cases need to be written.  The existing behaviour of the system should not change.  It should just run like usual.  Old tests should pass, new ones will most likely fail, and if old ones fail, I need to jump on that right away.

Minor crisis

gitea didn't survive the crash of my system and I had to register a new user.  This also means that my jenkins install is probably borked too.  For now, focus on the resume-builder and then later, recovery of jenkins.

Oh, and the suggestions from gemini was awful.  Sigh.  So I had to reinstall as the new user and then do the old git remote set-url origin http://localhost:3001... again and then git push -u origin main.

It sucks but we dust ourselves off and try to triage what went wrong and how to prevent this from happening again after doing up the meat and potatoes.

  

 Progress

gitea is up and running - checked in changes.  Good.

Refactored the  processing and analysis code into a class and a separate file for all that is good and happy in the universe.

Test cases are working - creating a bit more infrastructure around the test cases with some canned data for scenarios.  All job descriptions, etc... are but into a testing_data.yml file for reading in and then operating.

For example, one job description that does not match my skills is for a TasteTester at TidyBowl.  I should score a 0 with the analyzer on that one for sure.  I should also not have a cover letter produced by the LLM, and no skills gap.  There's no point in extra work when there isn't one needed. 

Now I can test the ResumeBuilder class in isolation.  Once this is under control, then some more test cases need to be written up to spark up the Flask application and then use selenium to test out the UI.  I like the UI as it is right now.  Might as well have concrete tests for it as I forge forward with the remainder of the functionality.

 

 

 

 

Networking Tonight

Because it's a Networking event (Tech Tuesday), I will be refining a few things, possibly doing a business card connect dump and then grabbing a shower, putting on my glad rags and then attending.

New flow

 

So the revision part is what's going in now - a level of persistence to be reflected on, regurgitated and checked again by a human.

Persistence is good

 

I was impressed with that - so now I can set up some kind of persistence within the conversation that will disappear when I quit.  Of course, logs will exist, but wow this has some real potential going forward.

Existence is pain

Monday Stuff

 

That does seem to be the plan.  

I am currently modifying the tool to move forward with some feedback and tinkering.

That's the fun part - let's see how it looks with the individual job descriptions modified and tailored to match the tone of the job description.

Prototyping

This was a success for one attempt - it was good to see how it all worked out.

I pumped in a known job description and managed to take my existing "Summary" and it created a new one that was more fitting for the job.  Now, it's time to take that into the code of resume-builder and put that modification in.

Consent

So, the next part after getting things rolling is to ensure that the proper consent is present for publishing the cover letter, and the possibly modified Summary section.

This will take a slightly higher priority in things.  So, a previewer, checks, and then publishing. 

Refinement of things is good.

 Okay - this is working.  

 

So yes, the filtering is getting  better and the prompt magic and temperature seems to be "the thing".

It is still generating a cover letter which I'll have to cut out.

I'm not dumping out the skills gap between my CV and the job description.  That can come next after I do some silly escape-code wrangling with the .yaml file and how pdflatex works.

Overall, it does look nice and the data is accurate.

 

Progress continues.

 And the improvements keep coming along:

 

So the flow is as follows: 

• Navigate to the site;
• Enter the Company Name this is used for storage;
• Enter the Position - this too is used for storage reasons;
• Copy and paste the Job Description
• Press "Analyze & Generate Drafts"

GUI Building time.

The GUI is now needed - a web-based approach so I can access it from around the world.

The GUI is simple for now

 

It will now generate the 5 levels of verbosity.  Now to integrate that with the "fitness" of the job description.

Fitness thoughts

Right now, just testing out my ollama instance with llama3.1 and seeing if it can match fitness between an existing job description and my .yaml file resume.

Data is entered, values, dates updated...

Today was a success - the format is now in.  The template .tex file is good to go, and the renderer.py script is generating the proper output to be converted to a PDF.

It looks clean and lovely.

It is checked into git and ready to be experimented with to add the levels of verbosity.

This is key to a successful venture.

 

 

 

Next day cleanup.

The renderer.py script was missing my "education" and "personal projects" section from the resume.  I fixed that, and with some other tweaking, the resume is looking much better.

I would like to add the final layer of verbosity: 

For each skill under a task, there should be an explanation as to why it was used, and notes about the implementation.

It's a bit of overkill, but I think it's worth it for ultra-verbose resumes.

       - task1: >-
          Client 1: Developed test automation of a large robotic
          thermal/pressure industrial system.  Wrote automated
          test cases for this system.
        skills:
          - Python
          - pytest
          - uiautomate
          - Selenium
          - Equipment Interfacing
          - C/C++
 

To this: 

        - task1: >-
          Client 1: Developed test automation of a large robotic
          thermal/pressure industrial system.  Wrote automated
          test cases for this system.
        skills:
          - name: Python
            level: 8/10
            reasons:
              - existing culture
              - rich ecosystem
            challenges:
              - first time working with Python and Windows
            benefits:
              - rapid development
        ...

Coming together

Yesterday I made progress with the resume conversion, cleanup, and the initial bundling up of some work with the LLM, and rendering the output of my resume.

Today's work will require some cleanup of the code, tweaks to the resume_template.tex, and then testing!!!

Why testing?  Because that's what I do.

Recovery

Ever have one of those moments where something rogue was eating up drive space such to the point that your browser acted strange and eventually you had to close it down, not knowing that everything wasn't being cached?

That was this morning.  This seems like problem.

Emails are mostly back up and running, linkedin account salvaged...

Nostalgia

The resume rebuild is going well - fixing up references, wording, and all placed into a yaml file.  I expanded some new fields:

tldr:

This is a short description of my role at a company.  It allows for a simple level of verbosity when generating resumes.

proudof:

This one I like - it highlights what I was proud of when working there.

overall structure

 
  - company: "<company name>"
    position: "<last job title>"
    location: "<city, province>"
    start_date: ""
    end_date: ""
    highlights:
      - tldr: >-
          What did I do there in an executive summary.
      - proudof: >-
          What did I do that I was most excited about or proud of.
      - task1: >-
          A bullet point of what was done while limiting skills/technologies
          specifically out for another level of verbosity.
        skills:
          A deeper level of verbosity - specific skills/technologies used.
          In particular, languages, management, protocols...
      - task2: >-
          ...
        skills:
          ...
 

I have contemplated putting another level of description for the skills.  This can round out my thinking at the time, implementation problems, etc...

 

Time for a shower and lunch!

So what's next?

Take that yaml file and a job description and then throw those at my local LLM and do some parsing magic.  Okay - there will be some playing around with the prompt so that the system believes that it's an expert technical career coach and resume writer.

Done

And, yes...

The output is a json format.  Time to take that out and pass it through a Jinja2 formatter - it's a great formatter - so I can output a LaTeX file.  Yes, I said LaTeX.  It can be easily dumped into a pdf file for laters with pdflatex.  Now is time to work on the formatter. 

 

 

 

Today's Run

Yesterday's work was good - I built a much better understanding of MCP-based systems with empirical applications.

Now, I have enough knowledge to understand that it's a lot of hard work to really coordinate things to create something akin to OpenClaw but not.

 

Something Else Has Popped Up

Back to MCP work for the pursuit of another position.

OAuth is our friend.

Back in the old days (11 or so years ago), it was simple enough to provide some credentials to your running application, and google was happy with that.  Agreed, an increase in security is important, but I will have to remind myself to regenerate the token.json file in my system every week.

The overview 

MCP is 'the bomb' these days with the cool kids.  So I had looked into this previously but I have decided to warm it up and work on it, my own solution system, and of course continue with the gtest, unified reporting for jenkins, and a personal project.

 

The steps

The steps  for my goal are as follows:

 

1. install llama 3.1 or 3.2 into my ollama system
2. dust off the google OAuth code that I had for calendars
3. set up mcp stuff for talking with my ollama system
4. set up mcp stuff with my calendar code
5. set up mcp stuff for my local jenkins system  
6. figure out server set up to interpret my org-mode files
7. set up mcp stuff for my emails

 

install llama 3.1 or 3.2 into my ollama system

Done - running llama3.1:latest.  Apparently the .json stuff for ollama and llama3.1 is a match made in heaven.

This is a perfect solution for an on-premises solution such as my own.

 

dust off the google OAuth code that I had for calendars

I had some code running from about 6 months ago to do the whole OAuth shenanigans and jumping about.

I needed to upgrade the version of python being used since in another week or so, the older versions won't be supported.

I love "pyenv local <version>".  This is such an incredible tool.

• confirm old calendars.py tool works
• repair environment with calendars.py after seeing warnings

 
pip freeze > requirements.txt
deactivate
rm -rf venv
pyenv local 3.14
python -m venv venv
python -m pip install -r requirements.txt
python calendars.py
(error regarding token) 
python get-credentials.py
(credentials retrieved!) 
python calendars.py
(expected output!)

set up mcp stuff for talking with my ollama system

ollama-first.py is written so I can communicate with ollama directly.  This works!

Sample ollama-mcp.py client code is present.

Now need the mcp server to begin this m-f'ng giggle fest.

This is now working for proving in the communication with ollama and mcp to google calendar. 

 

...
* September 23:
	+ Reach out, breathe, collect.
	+ Hunting
	+ House Chores
	+ Lunch
	+ Personal Projects
* September 24:
	+ Black bin, green bin, and yard trimmings
	+ Reach out, breathe, collect.
	+ Hunting
	+ House Chores
	+ Lunch
	+ Personal Projects
	+ TON of Demos
...
 

figure out server set up to interpret my org-mode files

Getting there - I had used an Effort tag in my system (think :DRAWER: format) and it's not quite in line with the duration estimates for projects.  I will try to update with changing the prompt out to using :Effort: and see if that helps.  If not, I will have to use the Scheduled fields for some reason or not...

 

I'm calling this at least close enough.  Server technology is coming along!

Email is doable!  Yay!

I needed to add gmail.readonly and the credentials for that.  So now...  The work flow will be:

 
read in email_list from a magic file
for each email in email_list:
  use calendar credential -> calendar.email.token.json
  use email credential -> gmail.email.token.json

set up mcp client and server with all .json files

have the server also read in the .todo files and put a watch on them for updates

then, if all goes well, the llm can be queried for things

Post I-Day

So it is back to post I-Day - a response at noon.  This is the plan.  Keep busy, do stuff, and wait for a response.

Moving forward:

Continue working with gtest, openCV and try to move it into a Jenkins build setup as well.

For fun, I'm working on a web-scraping tool for the lulz.

 

Well there were two paths:

1) good 

2) bad

 

If you're reading this, congratulations, we are in the universe that sucks. 

 

 

I-day.

It's I-day.

I am naturally nervous, but I know what I know, and what I don't know, I can learn.

I can do this.