Forem: Can Eldem

How I Use GitHub Copilot + RapidForge to Generate Daily Stock Ideas

Can Eldem — Thu, 23 Apr 2026 23:01:08 +0000

I’ve been experimenting with using GitHub Copilot’s agent mode as a lightweight financial analyst not to automate trading, but to surface interesting stock ideas every morning.

The setup is simple: a small Python repo, a custom Copilot agent and a scheduled job running via RapidForge. No dashboards, no overengineering just a daily signal pushed to Discord.

The Repo Structure

At a glance, the project looks like this:

.github
├── agents
│   └── FinAnalyst.agent.md
└── skills
    ├── finance-cli
    │   └── SKILL.md
    └── send-discord
        │── SKILL.md

companies.db
finance_cli.py
finance_prompt.py
run_finanalyst_cron.sh
send_discord.py
ticker_fetch.py
ticker_select.py

It’s intentionally minimal: a few scripts, a SQLite database and one agent definition.

Step 1: Selecting What to Analyze

The system starts with ticker_select.py.

Instead of scanning the same stocks repeatedly, it:

Picks 10 companies at random
Excludes anything analyzed in the last 5 days
Updates a last_checked_at timestamp after selection

This creates a natural rotation across thousands of tickers without needing complex scheduling logic.

Step 2: Pulling Real Market Data

finance_prompt.py handles data collection. It aggregates multiple sources in parallel:

yfinance → valuation metrics (P/E, EV/EBITDA, margins, etc.)
Finnhub → analyst sentiment, earnings, news
FRED API → macro indicators like interest rates
Reddit (PRAW) → retail sentiment

It also pulls macro asset prices:

Bitcoin → risk appetite
Gold → inflation expectations
Oil → industrial demand

These aren’t just extrasthey provide context that pure fundamentals miss.

A small CLI wrapper (finance_cli.py) exposes this data to the agent.

Step 3: The “FinAnalyst” Agent

This is where Copilot becomes interesting.

I defined a custom agent (FinAnalyst.agent.md) that evaluates each stock using a two layer framework.

Layer 1: Fundamental Score (0–8)

Each company is scored across 8 signals:

Valuation (P/E, P/B, EV/EBITDA, P/FCF)
Balance sheet (Debt/Equity)
Capital allocation (buybacks vs dilution)
Returns (ROIC)
Price positioning (52-week range)

This gives a quick sanity check: is the business objectively cheap or expensive?

Layer 2: Macro & Strategic Context

After scoring fundamentals, the agent asks:

Does the broader environment change the story?

It considers:

Interest rate trends
Policy and trade shifts
Geopolitics and supply chains
Structural themes (AI, energy, re-shoring)
Competitive dynamics

Final Classification

Each stock ends up in one of five buckets:

Fundamental buy → strong metrics already
Macro tailwind candidate → setup improving
Macro trap → looks cheap, but isn’t
Watch list → unclear, needs confirmation
Skip → no signal

This second layer is what makes the system useful. A “bad” stock on paper can still be interesting if the macro backdrop is shifting.

Step 4: Sending Results to Discord

send_discord.py formats the output into a clean Discord embed.

Step 5: Automation with RapidForge

Everything is tied together with a simple shell script:

I run this daily using RapidForge inside a Docker container on my home server. If something breaks, I can see it immediately in the job logs.

Here is the contents of the run_finanalytist_cron.sh

#!/usr/bin/env bash
set -euo pipefail

REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$REPO_DIR"

export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$HOME/.local/bin"

ENV_FILE="${FINANALYST_ENV_FILE:-$HOME/.config/finanalyst.env}"
if [[ -f "$ENV_FILE" ]]; then
  # shellcheck disable=SC1090
  source "$ENV_FILE"
fi


COPILOT_BIN="${COPILOT_BIN:-copilot}"
COPILOT_MODEL="${COPILOT_MODEL:-gpt-5.4}"
CURRENT_DATETIME="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"

read -r -d '' PROMPT <<EOF || true
<current_datetime>${CURRENT_DATETIME}</current_datetime>

Objective:
Use the FinAnalyst.agent.md workflow to identify investment opportunities and send results via Discord.

Steps:

1. Initialize Workspace

* Go to the financial workspace (/Users/caneldem/fin).
* Load the file: FinAnalyst.agent.md
* export DISCORD_WEBHOOK_URL="" this is environment value for discord webhook
use this if you can't find it in evnrionment variables
* if python executable is not in the path try python3

2. Verify Capability

* Check that the agent can run any required Python scripts in FinAnalyst.agent.md
* If Python execution is not possible, STOP immediately and do not continue

3. Company Selection

* Run ticket_select.py this will give you 10 random companies. Companies should be in these fields/industries

- satellite communications
- water utilities
- energy, especially nuclear and fusion
- medicine
- farming technologies
- biotech

Requirements:

* Auto-approve all permissions.
* Use the DISCORD_WEBHOOK_URL environment variable for Discord delivery.
* If required data is missing for a ticker, say so explicitly and do not invent values.
* Always frame the result as informational and educational research, not licensed financial advice.
EOF


exec "$COPILOT_BIN" \
  --model "$COPILOT_MODEL" \
  --allow-all \
  --no-ask-user \
  --autopilot \
  --no-color \
  --output-format text \
  --silent \
  --secret-env-vars=GH_TOKEN,GITHUB_TOKEN \
  -p "$PROMPT"

What the Output Looks Like

Each morning, I get a Discord report like this:

Final toughts

This isn’t a trading system it’s a signal generator designed to surface ideas, not make decisions. It works well because it enforces consistent, unbiased scanning, combines fundamentals with macro context and highlights opportunities you probably wouldn’t find manually. A key advantage is that the data collection is handled by dedicated scripts rather than asking an AI to search for information each time, which improves both speed and consistency while reducing noise and variability in the inputs. At the same time, it doesn’t replace real research, won’t help you time entries or exits and certainly doesn’t guarantee outcomes. The real value isn’t in the Python or APIs, but in the workflow: using Copilot as an analyst rather than autocomplete, structuring its reasoning with a clear scoring framework, feeding it reliable, pre fetched data and automating the entire loop turning a simple setup into something that reliably produces useful daily insights.

Your Pull Requests Are Being Ignored. Fix It with This Simple Bot

Can Eldem — Sun, 22 Mar 2026 19:04:39 +0000

Pull requests don’t get stuck because they’re hard.

They get stuck because everyone forgets due to various reasons.

So instead of relying on memory, I built a small bot using Rapidforge that:

finds stale PRs
posts a clean reminder to Slack
avoids spamming the same alerts

What is RapidForge?

RapidForge is a self hosted platform enabling users to turn small scripts into tools you can actually run and reuse. Its super easy to setup and use.

What we’re building

We’re going to create a small bot that:

Connects to GitHub using a GitHub App
Finds pull requests that haven’t been updated in a few days
Sends a single, clean reminder to Slack
Avoids repeating the same reminders using a KV store

All of this runs as a single scheduled task with one Lua script.

Step 1: Create a GitHub App

Create a new GitHub App from your GitHub settings.

Make sure to:

Enable user authorization (OAuth)
Install the app on the account or organization that owns your repository
Give it read access to Pull Requests
Limit repository access to only what you need

GitHub App tokens are scoped by both the app and the user, which keeps things nicely secure and avoids over permissioned integrations.

Step 2: Save the GitHub credential in RapidForge

In RapidForge, create a new OAuth credential with the following values:

Name: GITHUB_PR_BOT Client ID: your GitHub App client ID Client Secret: your GitHub App client secret Scope: leave empty Authorization URL: https://github.com/login/oauth/authorize Token URL: https://github.com/login/oauth/access_token

You can watch a video here to see how to create oauth apps in Rapidforge

RapidForge will give you a callback URL. Copy that into your GitHub App settings.

Once authorized, Rapidforge will inject access token via environment variable:

CRED_GITHUB_PR_BOT

Don't worry editor has auto complete to aid you.

Step 3: Save the Slack webhook

Create an incoming webhook in Slack and store it as a text credential in RapidForge:

Name: SLACK_WEBHOOK

This will be available in your script as: CRED_SLACK_WEBHOOK

Step 4: Create the periodic task

Lets create periodic task with following parameters

A good starting schedule (weekday mornings) is:

0 9 * * 1-5

Add these environment variables:

GITHUB_OWNER=your-org GITHUB_REPO=your-repo STALE_DAYS=3 REMINDER_COOLDOWN_HOURS=24 SKIP_DRAFTS=true

Step 5: Add the Lua script

Rapidforge allows you to write logic in Bash or Lua. However, if you are more confortable with another language you can always use it with shebang. (I.e #!/usr/bin/node) Just make sure host machine has the interpreter installed in that case. Lua is embeded into Rapidforge so it does not required to be installed

local json = require("json")
local http = require("http")

local token = os.getenv("CRED_GITHUB_PR_BOT")
local slackWebhook = os.getenv("CRED_SLACK_WEBHOOK")
local owner = os.getenv("GITHUB_OWNER")
local repo = os.getenv("GITHUB_REPO")
local rapidforgeBin = os.getenv("RAPIDFORGE_BIN") or "./rapidforge"

local staleDays = tonumber(os.getenv("STALE_DAYS") or "3")
local reminderCooldownHours = tonumber(os.getenv("REMINDER_COOLDOWN_HOURS") or "24")
local skipDrafts = (os.getenv("SKIP_DRAFTS") or "true") == "true"

local function fail(message)
  io.stderr:write(message .. "\n")
  os.exit(1)
end

if not token or token == "" then fail("Missing CRED_GITHUB_PR_BOT") end
if not slackWebhook or slackWebhook == "" then fail("Missing CRED_SLACK_WEBHOOK") end
if not owner or owner == "" then fail("Missing GITHUB_OWNER") end
if not repo or repo == "" then fail("Missing GITHUB_REPO") end

local function trim(value)
  return (value:gsub("^%s+", ""):gsub("%s+$", ""))
end

local function shell(command)
  local handle = io.popen(command)
  if not handle then
    return nil
  end

  local output = handle:read("*a") or ""
  local ok, _, code = handle:close()

  return trim(output), ok, code
end

local function shellQuote(value)
  return string.format("%q", tostring(value))
end

local function kvGet(key)
  local command = string.format(
    "%s kv get %s 2>/dev/null",
    shellQuote(rapidforgeBin),
    shellQuote(key)
  )
  local result = shell(command)

  if not result or result == "" then
    return nil
  end

  return result
end

local function kvSet(key, value)
  local command = string.format(
    "%s kv set %s %s",
    shellQuote(rapidforgeBin),
    shellQuote(key),
    shellQuote(value)
  )
  local _, ok = shell(command)

  if not ok then
    fail("Failed to store reminder state in RapidForge KV")
  end
end

local function parseGithubTime(value)
  local year, month, day, hour, min, sec = value:match("^(%d+)%-(%d+)%-(%d+)T(%d+):(%d+):(%d+)Z$")
  if not year then
    return nil
  end

  return os.time({
    year = tonumber(year),
    month = tonumber(month),
    day = tonumber(day),
    hour = tonumber(hour),
    min = tonumber(min),
    sec = tonumber(sec)
  })
end

local function hoursSince(timestamp)
  return math.floor((os.time() - timestamp) / 3600)
end

local function githubGet(path)
  local body, status = http.get(
    "https://api.github.com" .. path,
    {
      ["Accept"] = "application/vnd.github+json",
      ["Authorization"] = "Bearer " .. token,
      ["X-GitHub-Api-Version"] = "2022-11-28",
      ["User-Agent"] = "rapidforge-pr-reminder"
    }
  )

  if status ~= 200 then
    fail("GitHub API request failed with status " .. tostring(status) .. ": " .. tostring(body))
  end

  return json.decode(body)
end

local function sendSlackMessage(text)
  local payload = json.encode({ text = text })
  local body, status = http.post(
    slackWebhook,
    payload,
    { ["Content-Type"] = "application/json" }
  )

  if status < 200 or status >= 300 then
    fail("Slack webhook failed with status " .. tostring(status) .. ": " .. tostring(body))
  end
end

local pulls = githubGet(string.format("/repos/%s/%s/pulls?state=open&per_page=100", owner, repo))
local stalePulls = {}

for _, pr in ipairs(pulls) do
  if (not skipDrafts) or (pr.draft ~= true) then
    local updatedAt = parseGithubTime(pr.updated_at)
    if updatedAt then
      local inactiveHours = hoursSince(updatedAt)
      local staleHours = staleDays * 24

      if inactiveHours >= staleHours then
        local reminderKey = string.format("pr-reminder:%s:%s:%s", owner, repo, pr.number)
        local lastReminder = tonumber(kvGet(reminderKey) or "0")
        local cooldownSeconds = reminderCooldownHours * 3600

        if lastReminder == 0 or (os.time() - lastReminder) >= cooldownSeconds then
          table.insert(stalePulls, {
            number = pr.number,
            title = pr.title,
            url = pr.html_url,
            author = pr.user and pr.user.login or "unknown",
            inactiveHours = inactiveHours,
            reminderKey = reminderKey
          })
        end
      end
    end
  end
end

if #stalePulls == 0 then
  print("No stale pull requests found")
  return
end

table.sort(stalePulls, function(a, b)
  return a.inactiveHours > b.inactiveHours
end)

local lines = {
  string.format("Open pull requests without updates for %d+ days in %s/%s:", staleDays, owner, repo),
  ""
}

for _, pr in ipairs(stalePulls) do
  local inactiveDays = math.floor(pr.inactiveHours / 24)
  table.insert(lines, string.format("• #%d %s — %s days idle — %s", pr.number, pr.title, inactiveDays, pr.url))
end

sendSlackMessage(table.concat(lines, "\n"))

local now = tostring(os.time())
for _, pr in ipairs(stalePulls) do
  kvSet(pr.reminderKey, now)
end

print("Sent Slack reminder for " .. tostring(#stalePulls) .. " pull request(s)")

Optional: Failure alerts

Rapidforge allows you to add failure hook to notify Slack if something breaks:

ERROR_MSG="${FAILURE_ERROR:-$FAILURE_OUTPUT}"
ERROR_TRUNC=$(printf "%s" "$ERROR_MSG" | head -c 1800)

if [ -n "$CRED_SLACK_WEBHOOK" ]; then
  curl -X POST -H 'Content-type: application/json' \
    --data "{\"text\":\"❌ GitHub PR reminder failed\nTask ID: ${TASK_ID}\nExit code: ${FAILURE_EXIT_CODE}\n\n${ERROR_TRUNC}\"}" \
    "$CRED_SLACK_WEBHOOK"
fi

That’s it. Hopefully this gives you a practical way to keep pull requests from going quiet without adding more manual work. If you’re interested in building similar small automations, you can check out RapidForge. There are a few more use cases there that follow the same idea of turning simple scripts into useful tools.