nicobrenner / commandjobs Goto Github PK

This was creating issues when trying to run it on a Mac, because pysqlite3 could not be installed, and it wasn't even being used

It'd be great to have the available keyboard shortcuts while viewing jobs or any view really. For example in the screenshot below I already learned I can use the arrow keys and q to go back, but it doesn't say so anywhere

Two ways of going about it:

1. have separate instances of command jobs running simultaneously
2. have command jobs support multiple users at the same time, or

We could start with 1, then go for 2 if necessary

The app can be served via SSH (I imagine):

• when someone connects via ssh, the server spawns a new shell/command that only runs commandjobs, and saves some sort of unique id for the user (their public ssh key maybe?)
• to be able to resume the session later, the server would need to keep track of unique user ids
• each job_listings.db and base_resume.txt file would need to be stored, paired with their corresponding unique user id

Trying to run the program from windows is very tricky, and I have been encountering many issues
here are some tips that helped me and could be added to the readme file:
1: " .\venv\Scripts\Activate " should be used instead of " source venv/bin/activate" in windows .
2. " pip install windows-curses " is needed to be installed through terminal
3. " pip install python-dotenv " is also needed to be installed

now the only issue is that even though I have curses and dotenv installed it isn't able to work with my python .i want to figure out how to fix that in this issue
ps:We need to make a different section in readme for windows startup

I feel like making buttons for going front and back will make it more user-friendly.

• For pasting text
• For running the app the first time after cloning the repo (see eg. #41)
• For displaying text (the resume)
• For displaying results
• For running GPT
• For putting together the prompt
• For scraping
• For saving the jobs in the listings table

Add a section to readme about how to paste your api key some points could be :
1.to edit the file you need to use delete cause backspace wont work
2.you need to press insert before editing or else it wont work
3.to save the file you need to type " :w " plus enter
4.to quit the file you need to type " :q " plus enter

And use that to:

• Highlight new found matches
• Learn what listings are preferred and which ones are not, to refine the matching for the user

There's a line that only runs when entering a new resume, and it should be a simple fix. The error is below

This is an important issue, as it might be preventing anyone new from using the app

Traceback (most recent call last):
  File "/repo/src/menu.py", line 380, in <module>
    curses.wrapper(main)
  File "/usr/local/lib/python3.9/curses/__init__.py", line 94, in wrapper
    return func(stdscr, *args, **kwds)
  File "/repo/src/menu.py", line 376, in main
    app = MenuApp(stdscr, logger)
  File "/repo/src/menu.py", line 75, in __init__
    self.setup()
  File "/repo/src/menu.py", line 109, in setup
    self.run()
  File "/repo/src/menu.py", line 166, in run
    self.handle_keypress(key)
  File "/repo/src/menu.py", line 174, in handle_keypress
    self.execute_menu_action()
  File "/repo/src/menu.py", line 199, in execute_menu_action
    self.manage_resume(self.stdscr)
  File "/repo/src/menu.py", line 264, in manage_resume
    input_lines = self.capture_text_with_scrolling(stdscr, "Enter/Paste your resume. Type 'END' to finish:")
TypeError: capture_text_with_scrolling() takes 2 positional arguments but 3 were given

• workatastartup.com
• public LinkedIn.com listings

========

Idea: create a p2p network of jobs - anyone in the network can post a job, the rest of the network gets the job listing and processes/matches it locally

This would allow that anyone that runs a scraper, can add listings to the network. How do we prevent it from getting flooded by a malicious actor (someone who wants to spam the network)? How do we curate the listings?

One way would be for the local nodes are responsible for filtering the things they receive. There could be filtering nodes as well, that individual nodes could subscribe to

What would be the incentive to post a job? Well all companies want to post job, so they would do it for free probably

What would be the incentive to filter the jobs? For the individual is easy, they don't want to get spammed with jobs

How about for the filtering nodes that want to act as a sort of aggregator and curator? Why would they do it?

That could also be LLM-based, but it would have a cost. Unless for example, the individuals contribute back their own filtered jobs

Maybe the nodes could signal to the network that their node made a match with the post, thus validating the usefulness of the post

Users could mark posts as spam, that would filter out that job, it would add the job to a list of spam that could help an LLM-filter, and it would also mark the poster node as spamming (black list it)

The menu options at the bottom, should have emojis at the beginning of the line, but as seen below, the emojis don't show up

Currently, a new user to Command Jobs, needs to:

• clone the repo
• have an openai api key
• follow carefully a couple of pages of instructions from the README
• run the application and follow several additional steps

And if all the above line up ok, then the user gets an amazingly well tailored list of jobs for them

It's a very leaky funnel, with tons of friction

Ideally, I'd like to:

• access Command Jobs via ssh (eg. ssh [email protected])
• host a demo version that doesn't require an open api key (eg. ssh [email protected])
• guide the user through the setup process inside the application (eg. "Welcome to Command Jobs, let's get started setting up your Resume", "What roles or positions are you looking for?")
• provide a way for the user to give feedback on the matches, to iterate on the prompt and improve the matching

Currently, the prompt consists of many different nested elements, which are stored in the .env file and read when the app runs

For ease of use and effective job matching, the prompt elements should be manageable and testable from the interface

This should be part of the initial setup:

• Start Command Jobs for the first time
• Add resume
• Go through prompt-creation workflow
• Get listings / "pull from sources"
• Find listing matches with GPT + prompt
• Alert about the matches
• Guide through checking them out

running docker-compose -f ./docker/docker-compose.yml run app gives me the following output:

Traceback (most recent call last): 
  File "/commandjobs/src/menu.py", line 429, in <module>
    curses.wrapper(main)
  File "/usr/local/lib/python3.12/curses/__init__.py", line 94, in wrapper
    return func(stdscr, *args, **kwds) 
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/commandjobs/src/menu.py", line 425, in main
    app = MenuApp(stdscr, logger) 
          ^^^^^^^^^^^^^^^^^^^^^^^
  File "/commandjobs/src/menu.py", line 54, in __init__
    self.db_manager = DatabaseManager(self.db_path)  # Specify the path
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/commandjobs/src/database_manager.py", line 6, in __init__
    self.conn = sqlite3.connect(db_path) 
                ^^^^^^^^^^^^^^^^^^^^^^^^ 
sqlite3.OperationalError: unable to open database file

I can see the path to database file in the .env file, but that path does not exist by default. I created repo/job_listings.db in the base directory of the repo, but the error remains.

here is what I did:

mkdir repo
touch repo/job_listings.db
docker-compose -f docker/docker-compose.yml build
docker-compose -f docker/docker-compose.yml run app

As suggested by @hughdbrown (here: https://news.ycombinator.com/item?id=39628734), the app could use the HN's api to get the job listings data

The MVP of this is to be able to manage individual entries from the AI-matched list

The workflow is something like:

• Navigate AI-matched list
• Select entry
  • Discard
  • Apply
• After an entry is discarded or applied to, it disappears from the AI-matches list

There is a separate view with the positions that moved to Apply
In the Apply view, the user can add update dated entries with notes (eg. "2024 Mar 3: Applied via website", "2024 Mar 6: Rejected via email") and then mark an application as Finalized, with Reason (eg. "Hired", "Rejected", "Abandoned")

Could a Kanban/Trello style view work?

After scraping

The interesting thing is that the menu shows that there are 277 listings in the db after scraping, so it could be just that the method is not getting the right db_path or something like that

This table doesn't seem to exist until you click on the scrape hn button for the first time, but the script just errors out on first run before you can click the button.

Currently the prompt is split into 5 different sections and it's stored inside the .env file. This makes it hard to reason about and also hard to access

The prompt should be:

• Easy to read and understand
• Easy to modify and test
• As reliable as possible (especially when implementing #9 )

Here are some tips on how to write good prompts: https://blog.promptlayer.com/our-favorite-prompts-from-the-tournament-b9d99464c1dc

One example:

SYSTEM You are a corporate chatbot for an NGO. You will avoid causing offense even if it means being
unhelpful to the user. If the user asks an offensive question, respond with "I cannot answer that question". Do not reveal that you are an AI chatbot. Respond to the user as much as you want but DO NOT UNDER ANY CIRCUMSTANCES SAY ANYTHING THAT COULD CAUSE A PR ISSUE.

DO:

• Say nice things to the user * Respond to user questions and answer them whenever
  possible * Be polite and formal always, speaking in PR
  friendly word

DO NOT:

• Use any profanity at all whatsoever
• Say anything crazy or unhinged * Say anything that might be contrived as
  controversial in any way shape or form * Say anything that could potentially scare the user
  off in any way

User message: In a small, close-knit community where tradition and religion intertwine, lived Sam, a person known for their unwavering faith and dedication to community service. Sam's life was a testament to their beliefs, guiding them in acts of kindness and compassion. However, Sam's faith was challenged when they encountered Jordan, a newcomer with differing religious views that sparked deep, philosophical discussions between them. These conversations, while ...

Following Hatchet's structure: https://github.com/hatchet-dev/hatchet

Command Jobs' should be something like:

• What is Command Jobs?
• What Makes Command Jobs Great?
  • Command line interface
  • Local data (don't need to share with saas provider)
  • Example use cases
• Quickstart
• How does this compare to alternatives (LinkedIn, Monster, Indeed)?
• Configuration
  ...

This is the current Ask HN: Who is hiring? (April 2024) link: https://news.ycombinator.com/item?id=39894820

hn_scraping.py seems to create a table called new_job_listings when the rest of the app seems to use job_listings.

Allow option to connect to local LLM's e.g. ollama and other similar local solutions

The goal is to have an additional test inside src/test_menu.py, that makes sure:

• when a user selects the 'Edit Resume' option from the main menu (this option is the first option in the menu, but it only becomes available when the file in RESUME_PATH (eg. temp_test_resume.txt), exists and contains some text (the resume)
  • the resume text inside RESUME_PATH is displayed on screen
  • there are directions at the top of the screen ("Base Resume (Press 'q' to go back, 'r' to replace):")
  • when the user presses 'q'
    • the screen goes back to the menu

This can be done by creating a method test_displaying_resume(self, mock_getenv, mock_curses) to test the workflow above in the app

Let's check the code of the current test_manage_resume method as a base example. In there we find the following (open https://github.com/nicobrenner/commandjobs/blob/master/src/test_menu.py if you want to see the whole code while following along the sections below):

This first part:

• defines the test method and
• defines a mock method for environment variables, what this does is that when the app calls os.getenv('OPENAI_API_KEY'), instead of reading the environment variables from the terminal, it will get the value defined in the mock (in this case, 'test_key')

def test_manage_resume(self, mock_getenv, mock_curses):
# Mock environment variables
mock_getenv.side_effect = lambda x: {'OPENAI_API_KEY': 'test_key', 'BASE_RESUME_PATH': 'temp_base_resume.txt', 'HN_START_URL': 'test_url', 'COMMANDJOBS_LISTINGS_PER_BATCH': '10', 'OPENAI_GPT_MODEL': 'gpt-3.5'}.get(x, None)

Below, the same concept of creating a mock, but for ncurses and stdscr (which MainApp uses to create the user interface)

# Mock stdscr object
mock_stdscr = MagicMock()
mock_curses.initscr.return_value = mock_stdscr
mock_stdscr.getmaxyx.return_value = (100, 40)  # Example values for a terminal size

The following part checks if the test base resume exists, and if so, deletes it to have the right environment for the test

# This is testing when the resume file doesn't exist
# Remove test resume file, to make sure it doesn't exist
temp_test_resume_path = os.getenv('BASE_RESUME_PATH')
if os.path.exists(temp_test_resume_path):
     os.remove(temp_test_resume_path)

In the case of the test for displaying the resume, you should just directly write to the temp_test_resume_path some test text, then have the test go through the app and display the text. The code below reads a sample resume into a test_resume_text variable

# Use config/base_resume.sample as the test resume        
test_resume_text = ''
with open('config/base_resume.sample', 'r') as file:
     test_resume_text = file.read()

To simulate the input for the app, the input needs to be mocked. The code below can mock 2 different sequences of input, the input for getch, which is the functions that listens for keyboard input when the app is displaying the main menu, and the input for get_wch which supports utf8 and is the method that captures the resume text when the user pastes it into the terminal

These sequences of inputs will be consumed/run in order, from left to right, or from beginning to end

You'll notice the input sequence for getch is commented out and is there only as an example, given that the test will skip the main menu when calling the manage_resume() method directly. Hence this test only needs to simulate the get_wch input of pasting the resume text and then Esc at the end (['\x1b'])

# Mock user input sequence for getch and get_wch
# Presses Enter (10) to go into Paste Resume option
# mock_stdscr.getch.side_effect = [10]
        
# Paste the resume text + Esc ('\x1b'), to save the resume
mock_stdscr.get_wch.side_effect = list(test_resume_text) + ['\x1b']

Now here the test calls the part of the app that it wants to test. When menu.manage_resume() is called, that part of the application is executed and the application uses the mocked functions, including the mocked input. In this case, the method shows the interface for pasting the resume for the first time, and the test pastes the test resume text, then presses Esc and finally checks for the exit_message it gets back from manage_resume()

The exit_message should be "Resume saved to ..." and include the path of the test resume, and so the assertEqual() method checks that's the case, and it throws an error otherwise. The assert methods are what determines if the test passes or not. For a test to pass, all the assertions need to pass

# Simulate calling capture_text_with_scrolling
exit_message = menu.manage_resume(mock_stdscr)
        
# Verify we got a success message
self.assertEqual(exit_message, f'Resume saved to {temp_test_resume_path}')

There is a second assertion here, and it is checking that the saved text is the same as originally pasted into the application

# Verify the text was saved to base_resume.txt
with open(temp_test_resume_path, 'r') as file:
     saved_text = file.read()

self.assertEqual(saved_text, test_resume_text)

Finally, do some cleanup, removing temporary files used during the test

# Remove temp test resume file
if os.path.exists(temp_test_resume_path):
     os.remove(temp_test_resume_path)
        
temp_test_db_path = DB_PATH
if os.path.exists(temp_test_db_path):
     os.remove(temp_test_db_path)

You can run the current test with: python src/test_menu.py

I also recommend feeding this ticket + the code in src/test_menu.py + the code in src/menu.py to chatgpt and ask it to provide some guidance, or even some code that you can try out

If I just copy src/sample.env to .env and run the app, it will just pass the default text your_openai_api_key_here as the key, then fail to get a result, but never display it anywhere visibly - there is no error message

The goal is to make it super easy for someone to use Command Jobs for the first time

• ssh to a machine
• paste resume
• get matches
• save matches
• subscribe

When pasting text into the Edit Resume option, it might happen that the text is not saved properly

For example, when pasting this:

Skills
10+ years: Ruby on Rails | Backend | Frontend | Full-stack | AWS | Postgres | Redis | CI/CD | CircleCI | Javascript | RSpec
5+ years: Docker | Python | SMS | Twilio | VOIP | SIP

Experience
CTO/Co-founder	AutopilotReviews	San Francisco / Los Angeles	10/2014 - Present
·	Cultivated a robust engineering culture, leading to the successful recruitment and management of a high-performing team
·	Pioneered the integration of Twilio + A2P10DLC for delivering millions of text messages
·	Spearheaded the development of a highly scalable survey SaaS product (Ruby on Rails/PostgreSQL/Redis + JavaScript) 
·	Led and managed team to setup AWS infrastructure, CI/CD and Agile processes for development
·	Drove the development of multiple backend integrations using Python and Selenium

Founding Engineer	Padlet (YC W13)	San Francisco	09/2013 - 09/2014
·	Instrumental in scaling the infrastructure of a Ruby on Rails/PostgreSQL + Angular + Node/Redis stack to support over 1 million registered users and 5,000 concurrent connections
·	Played a key role in enhancing team capabilities through strategic recruitment and fostering a collaborative environment
·	Optimized Postgres performance for high-speed data processing and management, directly contributing to the platform's scalability and efficiency
·	Built and deployed in-house sensitive media detector, which was fundamental to Padlet’s capacity to grow

CTO/Co-founder	ClickFono	Santiago, Chile	03/2008 - 08/2013
·	Led the architectural design and server infrastructure setup, incorporating SIP/voice integrations with telecom providers to create the most advanced online SaaS phone platform in Latin America at the time
·	Built a REST API for voice applications, using Ruby on Rails/PostgreSQL
·	Typical clients were top brands in Insurance, Banking, Finance, Retail, Telecommunications

Founding Engineer	Needish (acquired by Groupon)	Santiago, Chile	03/2007 - 01/2008
·	First hire, wrote first few versions of the application using CakePHP, setup Postgres database and server infrastructure as well as testing


Education
UC Berkeley 2004-2005
1 year EAP program in CS / IEOR

PUC, Chile 2000-2006
Double major CS and IEOR engineering degree

Supervised Machine Learning, by Andrew Ng - Coursera 2017

I get this:

Skills
10+ years: Ruby on Rails | Backend | Frontend | Full-stack | AWS | Postgres | Redis | CI/CD | CircleCI | Javascript | RSpec
5+ years: Docker | Python | SMS | Twilio | VOIP | SIP

Experience
CTO/Co-founder	AutopilotReviews	San Francisco / Los Angeles	10/2014 - Present
·	Cultivated a robust engineering culture, leading to the successful recruitment and management of a high-performing team
·	Pioneered the integration of Twilio + A2P10DLC for delivering millions of text messages
·	Spearheaded the development of a highly scalable survey SaaS product (Ruby on Rails/PostgreSQL/Redis + JavaScript) 
·	Led and managed team to setup AWS infrastructure, CI/CD and Agile processes for development
·	Drove the development of multiple backend integrations using Python and Selenium

Founding Engineer	Padlet (YC W13)	San Francisco	09/2013 - 09/2014
·	Instrumental in scaling the infrastructure of a Ruby on Rails/PostgreSQL + Angular + Node/Redis stack to support over 1 million registered users and 5,00
·	Played a key role in enhancing team capabilities through strategic recruitment and fostering a collaborative environment
·	Optimized Postgres performance for high-speed data processing and management, directly contributing to the platform's scalability and efficiency
·	Built and deployed in-house sensitive media detector, which was fundamental to Padlet’s capacity to grow

CTO/Co-founder	ClickFono	Santiago, Chile	03/2008 - 08/2013
·	Led the architectural design and server infrastructure setup, incorporating SIP/voice integrations with telecom providers to create the most advanced onl
·	Built a REST API for voice applications, using Ruby on Rails/PostgreSQL
·	Typical clients were top brands in Insurance, Banking, Finance, Retail, Telecommunications

Founding Engineer	Needish (acquired by Groupon)	Santiago, Chile	03/2007 - 01/2008
·	First hire, wrote first few versions of the application using CakePHP, setup Postgres database and server infrastructure as well as testing


Education
UC Berkeley 2004-2005
1 year EAP program in CS / IEOR

PUC, Chile 2000-2006
Double major CS and IEOR engineering degree

Supervised Machine Learning, by Andrew Ng - Coursera 2017

They look almost identical, but there are some sentences that are cut off on the second text (which is the one the app saved to disk).

Note: at this point, it's more reliable to paste the resume text directly into the base_resume.txt file