step-overflow 0.1.0

package/dist/lib/achievements.js

@@ -0,0 +1,322 @@
+function getHour(record) {
+    return parseInt(record.datetime.split("T")[1]?.split(":")[0] ?? "12");
+}
+function getDate(record) {
+    return record.datetime.split("T")[0];
+}
+function getDayOfWeek(record) {
+    return new Date(record.datetime).getDay();
+}
+function hasMultipleOnSameDay(records) {
+    const dates = records.map(getDate);
+    return dates.length !== new Set(dates).size;
+}
+export const ACHIEVEMENTS = [
+    // ── Distance ──
+    {
+        id: "first_step",
+        name: "First Step",
+        description: "Record your first walk",
+        check: (ctx) => ctx.allRecords.length >= 1,
+    },
+    {
+        id: "10k",
+        name: "10K",
+        description: "Walk 10 km total",
+        check: (ctx) => ctx.totalKm >= 10,
+    },
+    {
+        id: "century",
+        name: "Century",
+        description: "Walk 100 km total",
+        check: (ctx) => ctx.totalKm >= 100,
+    },
+    {
+        id: "500_club",
+        name: "500 Club",
+        description: "Walk 500 km total",
+        check: (ctx) => ctx.totalKm >= 500,
+    },
+    {
+        id: "thousand",
+        name: "Thousand Miles",
+        description: "Walk 1,000 km total",
+        check: (ctx) => ctx.totalKm >= 1000,
+    },
+    {
+        id: "2000_club",
+        name: "2,000 Club",
+        description: "Walk further than the length of the Rhine",
+        check: (ctx) => ctx.totalKm >= 2000,
+    },
+    {
+        id: "5000_club",
+        name: "5,000 Club",
+        description: "Walk further than the length of Japan",
+        check: (ctx) => ctx.totalKm >= 5000,
+    },
+    {
+        id: "ten_thousand",
+        name: "10K Club",
+        description: "Five digits of distance",
+        check: (ctx) => ctx.totalKm >= 10000,
+    },
+    // ── Route Completion ──
+    {
+        id: "first_journey",
+        name: "First Journey",
+        description: "Complete your first route",
+        check: (ctx) => ctx.completedRoutes.length >= 1,
+    },
+    {
+        id: "alpinist",
+        name: "Alpinist",
+        description: "Circle Mont Blanc through three countries",
+        check: (ctx) => ctx.completedRoutes.includes("tmb"),
+    },
+    {
+        id: "tokaido_master",
+        name: "Tokaido Master",
+        description: "Walk the path of the samurai",
+        check: (ctx) => ctx.completedRoutes.includes("tokaido"),
+    },
+    {
+        id: "pharaohs_path",
+        name: "Pharaoh's Path",
+        description: "Walk the Nile from Aswan to the Pyramids",
+        check: (ctx) => ctx.completedRoutes.includes("nile_valley"),
+    },
+    {
+        id: "hannibals_legacy",
+        name: "Hannibal's Legacy",
+        description: "March with elephants across the Alps",
+        check: (ctx) => ctx.completedRoutes.includes("hannibal"),
+    },
+    {
+        id: "via_francigena",
+        name: "Via Francigena",
+        description: "Pilgrim from Canterbury to the Eternal City",
+        check: (ctx) => ctx.completedRoutes.includes("via_francigena"),
+    },
+    {
+        id: "pilgrim",
+        name: "Pilgrim",
+        description: "Complete the Camino de Santiago",
+        check: (ctx) => ctx.completedRoutes.includes("camino"),
+    },
+    {
+        id: "route66_rider",
+        name: "Route 66 Rider",
+        description: "Get your kicks on Route 66",
+        check: (ctx) => ctx.completedRoutes.includes("route66"),
+    },
+    {
+        id: "desert_caravan",
+        name: "Desert Caravan",
+        description: "Cross the Sahara with gold and salt",
+        check: (ctx) => ctx.completedRoutes.includes("trans_sahara"),
+    },
+    {
+        id: "sun_walker",
+        name: "Sun Walker",
+        description: "Walk the Royal Road of the Sun",
+        check: (ctx) => ctx.completedRoutes.includes("qhapaq_nan"),
+    },
+    {
+        id: "spice_master",
+        name: "Spice Master",
+        description: "Master the seas of the spice trade",
+        check: (ctx) => ctx.completedRoutes.includes("spice_trader"),
+    },
+    {
+        id: "silk_merchant",
+        name: "Silk Merchant",
+        description: "Trade silk and ideas across continents",
+        check: (ctx) => ctx.completedRoutes.includes("silk_road"),
+    },
+    {
+        id: "transcontinental",
+        name: "Transcontinental",
+        description: "Cross a continent on foot",
+        check: (ctx) => ctx.completedRoutes.includes("route66") ||
+            ctx.completedRoutes.includes("around"),
+    },
+    {
+        id: "globe_trotter",
+        name: "Globe Trotter",
+        description: "Complete Around the World",
+        check: (ctx) => ctx.completedRoutes.includes("around"),
+    },
+    // ── Route Collection ──
+    {
+        id: "world_traveler",
+        name: "World Traveler",
+        description: "Complete 3 routes",
+        check: (ctx) => ctx.completedRoutes.length >= 3,
+    },
+    {
+        id: "five_journeys",
+        name: "Five Journeys",
+        description: "Complete 5 different routes",
+        check: (ctx) => ctx.completedRoutes.length >= 5,
+    },
+    {
+        id: "legendary_walker",
+        name: "Legendary Walker",
+        description: "Walk every route in the world",
+        check: (ctx) => ctx.completedRoutes.length >= 12,
+    },
+    // ── Single Walk Records ──
+    {
+        id: "five_k_walk",
+        name: "5K Walk",
+        description: "Walk 5 km in a single session",
+        check: (ctx) => ctx.allRecords.some((r) => r.distance_km >= 5),
+    },
+    {
+        id: "ten_k_walk",
+        name: "10K Walk",
+        description: "Double digits in a single walk",
+        check: (ctx) => ctx.allRecords.some((r) => r.distance_km >= 10),
+    },
+    {
+        id: "half_marathon",
+        name: "Half Marathon",
+        description: "Complete a half marathon distance",
+        check: (ctx) => ctx.allRecords.some((r) => r.distance_km >= 21.1),
+    },
+    {
+        id: "marathon",
+        name: "Marathon",
+        description: "Walk 42.195 km in a single session",
+        check: (ctx) => ctx.allRecords.some((r) => r.distance_km >= 42.195),
+    },
+    {
+        id: "speed_demon",
+        name: "Speed Demon",
+        description: "Walk at 6+ km/h",
+        check: (ctx) => ctx.allRecords.some((r) => r.speed_kmh >= 6),
+    },
+    {
+        id: "long_haul",
+        name: "Long Haul",
+        description: "Walk 120+ minutes in a single session",
+        check: (ctx) => ctx.allRecords.some((r) => r.time_min >= 120),
+    },
+    // ── Time & Habit ──
+    {
+        id: "early_bird",
+        name: "Early Bird",
+        description: "Record a walk before 6:00 AM",
+        check: (ctx) => ctx.allRecords.some((r) => getHour(r) < 6),
+    },
+    {
+        id: "night_owl",
+        name: "Night Owl",
+        description: "Record a walk after 22:00",
+        check: (ctx) => ctx.allRecords.some((r) => getHour(r) >= 22),
+    },
+    {
+        id: "weekend_warrior",
+        name: "Weekend Warrior",
+        description: "Record a walk on the weekend",
+        check: (ctx) => ctx.allRecords.some((r) => {
+            const day = getDayOfWeek(r);
+            return day === 0 || day === 6;
+        }),
+    },
+    {
+        id: "double_up",
+        name: "Double Up",
+        description: "Record two walks in a single day",
+        check: (ctx) => hasMultipleOnSameDay(ctx.allRecords),
+    },
+    // ── Walk Count ──
+    {
+        id: "5_walks",
+        name: "5 Walks",
+        description: "Your first handful of walks",
+        check: (ctx) => ctx.allRecords.length >= 5,
+    },
+    {
+        id: "10_walks",
+        name: "10 Walks",
+        description: "Double digits",
+        check: (ctx) => ctx.allRecords.length >= 10,
+    },
+    {
+        id: "50_walks",
+        name: "50 Walks",
+        description: "Halfway to a hundred",
+        check: (ctx) => ctx.allRecords.length >= 50,
+    },
+    {
+        id: "100_walks",
+        name: "100 Walks",
+        description: "The Centurion",
+        check: (ctx) => ctx.allRecords.length >= 100,
+    },
+    {
+        id: "200_walks",
+        name: "200 Walks",
+        description: "Walking is part of your life",
+        check: (ctx) => ctx.allRecords.length >= 200,
+    },
+    {
+        id: "300_walks",
+        name: "300 Walks",
+        description: "A walk a day keeps the doctor away",
+        check: (ctx) => ctx.allRecords.length >= 300,
+    },
+    {
+        id: "400_walks",
+        name: "400 Walks",
+        description: "Your shoes need replacing",
+        check: (ctx) => ctx.allRecords.length >= 400,
+    },
+    {
+        id: "500_walks",
+        name: "500 Walks",
+        description: "Half a thousand steps forward",
+        check: (ctx) => ctx.allRecords.length >= 500,
+    },
+    {
+        id: "600_walks",
+        name: "600 Walks",
+        description: "The road knows your name",
+        check: (ctx) => ctx.allRecords.length >= 600,
+    },
+    {
+        id: "700_walks",
+        name: "700 Walks",
+        description: "Walking legend in the making",
+        check: (ctx) => ctx.allRecords.length >= 700,
+    },
+    {
+        id: "800_walks",
+        name: "800 Walks",
+        description: "Unstoppable force of nature",
+        check: (ctx) => ctx.allRecords.length >= 800,
+    },
+    {
+        id: "900_walks",
+        name: "900 Walks",
+        description: "The final stretch to four digits",
+        check: (ctx) => ctx.allRecords.length >= 900,
+    },
+    {
+        id: "1000_walks",
+        name: "1,000 Walks",
+        description: "One thousand walks. Legendary.",
+        check: (ctx) => ctx.allRecords.length >= 1000,
+    },
+    {
+        id: "10000_walks",
+        name: "10,000 Walks",
+        description: "Beyond all limits",
+        check: (ctx) => ctx.allRecords.length >= 10000,
+    },
+];
+export function checkNewAchievements(ctx, unlocked) {
+    return ACHIEVEMENTS.filter((a) => !unlocked[a.id] && a.check(ctx));
+}

package/dist/lib/animation.js

@@ -0,0 +1,70 @@
+import logUpdate from "log-update";
+// 6-frame running stick figure with arm swing and leg stride
+// Each frame: head, torso+arms, legs (all 5 chars wide for alignment)
+const FRAMES = [
+    // Frame 0: right leg forward stride, left arm reach
+    [
+        "  o  ",
+        " -|\\ ",
+        " / > ",
+    ],
+    // Frame 1: legs crossing, arms pull in
+    [
+        "  o  ",
+        " /|\\ ",
+        "  || ",
+    ],
+    // Frame 2: left leg forward stride, right arm reach
+    [
+        "  o  ",
+        " /|- ",
+        " < \\ ",
+    ],
+    // Frame 3: push off, legs crossing back
+    [
+        "  o  ",
+        " /|\\ ",
+        "  || ",
+    ],
+    // Frame 4: airborne, legs tucked
+    [
+        "  o  ",
+        " -|- ",
+        " > < ",
+    ],
+    // Frame 5: landing, arms down
+    [
+        "  o  ",
+        " /|\\ ",
+        " / \\ ",
+    ],
+];
+const GROUND_CHAR = "\u2500";
+const GROUND_LEN = 46;
+export async function playWalkAnimation(until, minMs = 1000) {
+    const frameWidth = 5;
+    let frameIdx = 0;
+    let pos = 0;
+    const interval = setInterval(() => {
+        const frame = FRAMES[frameIdx % FRAMES.length];
+        const pad = " ".repeat(pos);
+        const ground = GROUND_CHAR.repeat(GROUND_LEN);
+        const lines = [
+            pad + frame[0],
+            pad + frame[1],
+            pad + frame[2],
+            ground,
+        ];
+        logUpdate(lines.join("\n"));
+        frameIdx++;
+        pos += 2;
+        if (pos > GROUND_LEN - frameWidth)
+            pos = 0;
+    }, 120);
+    await Promise.all([
+        until.catch(() => { }),
+        new Promise((resolve) => setTimeout(resolve, minMs)),
+    ]);
+    clearInterval(interval);
+    logUpdate.clear();
+}

package/dist/lib/calories.js

@@ -0,0 +1,32 @@
+// MET values for walking (Compendium of Physical Activities)
+// Speed (km/h) -> METs mapping points for linear interpolation
+const MET_TABLE = [
+    [2.0, 2.0],
+    [3.2, 2.8],
+    [4.0, 3.5],
+    [4.8, 4.3],
+    [5.6, 5.0],
+    [6.4, 7.0],
+    [8.0, 8.3],
+];
+export function getMets(speedKmh) {
+    if (speedKmh <= MET_TABLE[0][0])
+        return MET_TABLE[0][1];
+    if (speedKmh >= MET_TABLE[MET_TABLE.length - 1][0]) {
+        return MET_TABLE[MET_TABLE.length - 1][1];
+    }
+    for (let i = 0; i < MET_TABLE.length - 1; i++) {
+        const [s0, m0] = MET_TABLE[i];
+        const [s1, m1] = MET_TABLE[i + 1];
+        if (speedKmh >= s0 && speedKmh <= s1) {
+            const ratio = (speedKmh - s0) / (s1 - s0);
+            return m0 + ratio * (m1 - m0);
+        }
+    }
+    return 3.5; // fallback: normal walking
+}
+export function calcCalories(speedKmh, timeMin, weightKg) {
+    const mets = getMets(speedKmh);
+    const timeHours = timeMin / 60;
+    return Math.round(mets * weightKg * timeHours);
+}

package/dist/lib/config.js

@@ -0,0 +1,38 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function xdgConfigHome() {
+    return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+}
+function xdgDataHome() {
+    return process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+}
+const CONFIG_DIR = join(xdgConfigHome(), "step-overflow");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+export function getDataDir() {
+    return join(xdgDataHome(), "step-overflow");
+}
+export function configExists() {
+    return existsSync(CONFIG_PATH);
+}
+export async function loadConfig() {
+    if (!configExists()) {
+        throw new Error("step-overflow is not initialized. Run `stp init` first.");
+    }
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+}
+export async function saveConfig(config) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+export function getCsvPath(config) {
+    return join(config.local_path, "data", "walking.csv");
+}
+export function getPagesUrl(config) {
+    if (config.visibility === "private")
+        return null;
+    const repoName = config.repo.split("/")[1];
+    return `https://${config.username}.github.io/${repoName}/`;
+}

package/dist/lib/csv.js

@@ -0,0 +1,55 @@
+import { readFile, appendFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+const HEADER = "datetime,time_min,speed_kmh,distance_km,weight_kg";
+export async function appendRecord(csvPath, record) {
+    const dir = dirname(csvPath);
+    await mkdir(dir, { recursive: true });
+    if (!existsSync(csvPath)) {
+        await writeFile(csvPath, HEADER + "\n");
+    }
+    const weight = record.weight_kg !== null ? String(record.weight_kg) : "";
+    const line = [
+        record.datetime,
+        record.time_min,
+        record.speed_kmh,
+        record.distance_km.toFixed(2),
+        weight,
+    ].join(",");
+    await appendFile(csvPath, line + "\n");
+}
+export async function readRecords(csvPath) {
+    if (!existsSync(csvPath))
+        return [];
+    const content = await readFile(csvPath, "utf-8");
+    const lines = content.trim().split("\n");
+    if (lines.length < 2)
+        return [];
+    return lines.slice(1).flatMap((line) => {
+        const parts = line.split(",");
+        if (parts.length < 4)
+            return [];
+        const [datetime, time_min, speed_kmh, distance_km, weight_kg] = parts;
+        const record = {
+            datetime,
+            time_min: parseFloat(time_min),
+            speed_kmh: parseFloat(speed_kmh),
+            distance_km: parseFloat(distance_km),
+            weight_kg: weight_kg ? parseFloat(weight_kg) || null : null,
+        };
+        if (isNaN(record.time_min) || isNaN(record.speed_kmh) || isNaN(record.distance_km)) {
+            return [];
+        }
+        return [record];
+    });
+}
+export async function initCsv(csvPath) {
+    await mkdir(dirname(csvPath), { recursive: true });
+    try {
+        await writeFile(csvPath, HEADER + "\n", { flag: "wx" });
+    }
+    catch (e) {
+        if (e.code !== "EEXIST")
+            throw e;
+    }
+}

package/dist/lib/git.js

@@ -0,0 +1,97 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+async function run(cmd, args, cwd) {
+    return exec(cmd, args, { cwd });
+}
+export async function checkPrerequisites() {
+    let git = false;
+    let gh = false;
+    try {
+        await run("git", ["--version"]);
+        git = true;
+    }
+    catch { }
+    try {
+        await run("gh", ["--version"]);
+        gh = true;
+    }
+    catch { }
+    return { git, gh };
+}
+export async function isGhAuthenticated() {
+    try {
+        await run("gh", ["auth", "status"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getGhUsername() {
+    const { stdout } = await run("gh", [
+        "api",
+        "user",
+        "--jq",
+        ".login",
+    ]);
+    return stdout.trim();
+}
+export async function createRepo(name, visibility) {
+    const { stdout } = await run("gh", [
+        "repo",
+        "create",
+        name,
+        `--${visibility}`,
+    ]);
+    return stdout.trim();
+}
+export async function enableGitHubPages(fullName) {
+    try {
+        await run("gh", [
+            "api",
+            "--method",
+            "POST",
+            `repos/${fullName}/pages`,
+            "-f",
+            "build_type=legacy",
+            "-f",
+            "source[branch]=main",
+            "-f",
+            "source[path]=/docs",
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function gitAdd(files, cwd) {
+    await run("git", ["add", ...files], cwd);
+}
+export async function gitCommit(message, cwd) {
+    await run("git", ["commit", "-m", message], cwd);
+}
+export async function gitPush(cwd) {
+    await run("git", ["push"], cwd);
+}
+export async function hasUnpushedCommits(cwd) {
+    try {
+        const { stdout } = await run("git", ["log", "--oneline", "origin/main..HEAD"], cwd);
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function gitInit(cwd) {
+    await run("git", ["init"], cwd);
+    await run("git", ["branch", "-M", "main"], cwd);
+}
+export async function gitAddRemote(fullName, cwd) {
+    const url = `https://github.com/${fullName}.git`;
+    await run("git", ["remote", "add", "origin", url], cwd);
+}
+export async function gitPushFirst(cwd) {
+    await run("git", ["push", "-u", "origin", "main"], cwd);
+}