step-overflow 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,193 @@
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { configExists, saveConfig, getPagesUrl, getDataDir, } from "../lib/config.js";
+import { ROUTES, formatRouteOption } from "../lib/routes.js";
+import { checkPrerequisites, isGhAuthenticated, getGhUsername, createRepo, gitInit, gitAdd, gitCommit, gitAddRemote, gitPushFirst, enableGitHubPages, } from "../lib/git.js";
+import { initCsv } from "../lib/csv.js";
+import { generateIndexHtml } from "../lib/html.js";
+import { promptText, promptSelect, promptConfirm } from "../lib/prompt.js";
+async function promptRepoName(current) {
+    return promptText("Repository name:", {
+        placeholder: "my-walking-log",
+        default: current ?? "my-walking-log",
+    });
+}
+async function promptVisibility(current) {
+    return promptSelect("Repository visibility:", ["private", "public"], current);
+}
+async function promptSpeed(current) {
+    while (true) {
+        const val = await promptText("Default walking speed (km/h):", {
+            placeholder: "4.0",
+            default: String(current ?? 4.0),
+        });
+        const parsed = parseFloat(val);
+        if (!isNaN(parsed) && parsed > 0)
+            return parsed;
+        consola.warn("Please enter a valid positive number.");
+    }
+}
+async function promptWeight(current) {
+    while (true) {
+        const val = await promptText(current ? `Weight (kg) [optional, current: ${current}]:` : "Weight (kg) [optional]:", { placeholder: "" });
+        if (!val)
+            return null;
+        const parsed = parseFloat(val);
+        if (!isNaN(parsed) && parsed > 0)
+            return parsed;
+        consola.warn("Please enter a valid positive number, or press Enter to skip.");
+    }
+}
+async function promptInputs() {
+    const inputs = {
+        repoName: await promptRepoName(),
+        visibility: await promptVisibility(),
+        defaultSpeed: await promptSpeed(),
+        weightKg: await promptWeight(),
+    };
+    while (true) {
+        const weightDisplay = inputs.weightKg ? `${inputs.weightKg} kg` : "not set";
+        consola.box(`Repository:  ${inputs.repoName} (${inputs.visibility})\n` +
+            `Speed:       ${inputs.defaultSpeed} km/h\n` +
+            `Weight:      ${weightDisplay}`);
+        if (await promptConfirm("Confirm settings?", true))
+            break;
+        const field = await promptSelect("Which setting to change?", [
+            "Repository name",
+            "Visibility",
+            "Speed",
+            "Weight",
+        ]);
+        switch (field) {
+            case "Repository name":
+                inputs.repoName = await promptRepoName(inputs.repoName);
+                break;
+            case "Visibility":
+                inputs.visibility = await promptVisibility(inputs.visibility);
+                break;
+            case "Speed":
+                inputs.defaultSpeed = await promptSpeed(inputs.defaultSpeed);
+                break;
+            case "Weight":
+                inputs.weightKg = await promptWeight(inputs.weightKg);
+                break;
+        }
+    }
+    return inputs;
+}
+export const initCommand = defineCommand({
+    meta: { name: "init", description: "Initialize step-overflow" },
+    run: async () => {
+        if (configExists()) {
+            consola.error("step-overflow is already initialized.");
+            consola.info("To re-initialize, delete the config and data directories first.");
+            process.exit(1);
+        }
+        // 1. Check prerequisites
+        const prereqs = await checkPrerequisites();
+        if (!prereqs.git) {
+            consola.error("git is not installed. Please install git first.");
+            process.exit(1);
+        }
+        if (!prereqs.gh) {
+            consola.error("GitHub CLI (gh) is not installed. Install from https://cli.github.com/");
+            process.exit(1);
+        }
+        consola.start("Checking GitHub CLI authentication...");
+        if (!(await isGhAuthenticated())) {
+            consola.error("GitHub CLI is not authenticated. Run `gh auth login` first.");
+            process.exit(1);
+        }
+        consola.success("GitHub CLI authenticated.");
+        const username = await getGhUsername();
+        // 2. Prompt inputs
+        const { repoName, visibility, defaultSpeed, weightKg } = await promptInputs();
+        const fullName = `${username}/${repoName}`;
+        const localPath = join(getDataDir(), repoName);
+        // 3. Choose journey route
+        const routeOptions = ROUTES.map(formatRouteOption);
+        const selectedOption = await promptSelect("Choose your journey:", routeOptions);
+        const selectedRoute = ROUTES[routeOptions.indexOf(selectedOption)];
+        const journey = {
+            route_id: selectedRoute.id,
+            started_at: new Date().toISOString().slice(0, 19),
+            started_km: 0,
+            completed_routes: [],
+        };
+        // Build config early so we can pass it to HTML generator
+        const config = {
+            repo: fullName,
+            local_path: localPath,
+            default_speed: defaultSpeed,
+            weight_kg: weightKg,
+            username,
+            visibility,
+            journey,
+            achievements: {},
+        };
+        // 4. Create GitHub repo
+        consola.start(`Creating repository ${fullName} (${visibility})...`);
+        try {
+            await createRepo(repoName, visibility);
+            consola.success("Repository created.");
+        }
+        catch (e) {
+            const err = e;
+            if (err.stderr?.includes("already exists")) {
+                consola.warn("Repository already exists on GitHub, continuing...");
+            }
+            else {
+                consola.error(`Failed to create repository: ${err.message}`);
+                process.exit(1);
+            }
+        }
+        // 5. Create local directory and init git
+        consola.start(`Setting up local directory: ${localPath}`);
+        await mkdir(localPath, { recursive: true });
+        await gitInit(localPath);
+        await gitAddRemote(fullName, localPath);
+        // 6. Create initial files
+        const csvPath = join(localPath, "data", "walking.csv");
+        await initCsv(csvPath);
+        const docsDir = join(localPath, "docs");
+        await mkdir(docsDir, { recursive: true });
+        await writeFile(join(docsDir, "index.html"), generateIndexHtml(config));
+        // 7. Initial commit and push
+        consola.start("Committing and pushing initial files...");
+        await gitAdd(["data/walking.csv", "docs/index.html"], localPath);
+        await gitCommit("Initial commit by step-overflow", localPath);
+        try {
+            await gitPushFirst(localPath);
+            consola.success("Pushed to GitHub.");
+        }
+        catch (e) {
+            const err = e;
+            consola.warn(`Push failed: ${err.message}. You can retry with \`stp sync\`.`);
+        }
+        // 8. Enable GitHub Pages for public repos
+        if (visibility === "public") {
+            consola.start("Enabling GitHub Pages...");
+            const pagesOk = await enableGitHubPages(fullName);
+            if (pagesOk) {
+                consola.success("GitHub Pages enabled.");
+            }
+            else {
+                consola.warn("Could not enable GitHub Pages automatically. Enable it manually in repo settings.");
+            }
+        }
+        // 9. Save config and display summary
+        await saveConfig(config);
+        const pagesUrl = getPagesUrl(config);
+        consola.box(`step-overflow initialized!\n\n` +
+            `Repo:    ${fullName}\n` +
+            `Local:   ${localPath}\n` +
+            `Speed:   ${defaultSpeed} km/h\n` +
+            (weightKg ? `Weight:  ${weightKg} kg\n` : "") +
+            `Journey: ${selectedRoute.from} \u2192 ${selectedRoute.to} (${selectedRoute.total_km.toLocaleString()} km)\n` +
+            (pagesUrl
+                ? `Pages:   ${pagesUrl}`
+                : `Visibility: private (use \`stp open\` to view locally)`));
+    },
+});

package/dist/commands/log.js

@@ -0,0 +1,41 @@
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { loadConfig, getCsvPath } from "../lib/config.js";
+import { readRecords } from "../lib/csv.js";
+import { calcCalories } from "../lib/calories.js";
+export const logCommand = defineCommand({
+    meta: { name: "log", description: "Show recent walking records" },
+    args: {
+        count: {
+            type: "string",
+            description: "Number of records to show (default: 10)",
+            default: "10",
+        },
+    },
+    run: async ({ args }) => {
+        const config = await loadConfig();
+        const csvPath = getCsvPath(config);
+        const records = await readRecords(csvPath);
+        if (records.length === 0) {
+            consola.info("No records yet. Run `stp add <minutes>` to start.");
+            return;
+        }
+        const count = Math.min(parseInt(args.count) || 10, records.length);
+        const recent = records.slice(-count).reverse();
+        const lines = recent.map((r) => {
+            const date = r.datetime.split("T")[0];
+            const time = r.datetime.split("T")[1]?.slice(0, 5) || "";
+            let line = `  ${date} ${time}  ${String(r.time_min).padStart(4)} min  ${r.speed_kmh} km/h  ${r.distance_km.toFixed(2)} km`;
+            if (r.weight_kg) {
+                const cal = calcCalories(r.speed_kmh, r.time_min, r.weight_kg);
+                line += `  ${cal} kcal`;
+            }
+            return line;
+        });
+        consola.log(`\nLast ${count} records:\n`);
+        for (const line of lines) {
+            consola.log(line);
+        }
+        consola.log("");
+    },
+});

package/dist/commands/open.js

@@ -0,0 +1,78 @@
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { join, extname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { loadConfig, getPagesUrl } from "../lib/config.js";
+import { openInBrowser } from "../lib/open-url.js";
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".csv": "text/csv",
+    ".json": "application/json",
+};
+export const openCommand = defineCommand({
+    meta: { name: "open", description: "Open walking log in browser" },
+    args: {
+        remote: {
+            type: "boolean",
+            description: "Open GitHub Pages URL instead of local file",
+            default: false,
+        },
+    },
+    run: async ({ args }) => {
+        const config = await loadConfig();
+        if (args.remote) {
+            const url = getPagesUrl(config);
+            if (!url) {
+                consola.error("GitHub Pages is not available for private repositories.");
+                consola.info("Use `stp open` without --remote to open locally.");
+                process.exit(1);
+            }
+            consola.info(`Opening ${url}`);
+            await openInBrowser(url);
+            return;
+        }
+        const repoRoot = config.local_path;
+        const docsDir = join(repoRoot, "docs");
+        if (!existsSync(join(docsDir, "index.html"))) {
+            consola.error("docs/index.html not found. Run `stp init` first.");
+            process.exit(1);
+        }
+        // Start local HTTP server serving the repo root
+        const server = createServer(async (req, res) => {
+            const rawUrl = new URL(req.url, "http://localhost").pathname;
+            const urlPath = rawUrl === "/" ? "/docs/index.html" : rawUrl;
+            const filePath = resolve(repoRoot, urlPath.replace(/^\//, ""));
+            // Prevent path traversal
+            if (!filePath.startsWith(repoRoot + "/") && filePath !== repoRoot) {
+                res.writeHead(403);
+                res.end("Forbidden");
+                return;
+            }
+            try {
+                const content = await readFile(filePath);
+                const ext = extname(filePath);
+                res.writeHead(200, { "Content-Type": MIME_TYPES[ext] || "application/octet-stream" });
+                res.end(content);
+            }
+            catch {
+                res.writeHead(404);
+                res.end("Not found");
+            }
+        });
+        server.listen(0, "127.0.0.1", async () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                consola.error("Failed to start server.");
+                return;
+            }
+            const url = `http://127.0.0.1:${addr.port}`;
+            consola.success(`Server running at ${url}`);
+            consola.info("Press Ctrl+C to stop.");
+            await openInBrowser(url);
+        });
+    },
+});

package/dist/commands/status.js

@@ -0,0 +1,55 @@
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { loadConfig, getPagesUrl, getCsvPath } from "../lib/config.js";
+import { isGhAuthenticated, hasUnpushedCommits } from "../lib/git.js";
+import { readRecords } from "../lib/csv.js";
+import { getRoute, getProgress, progressBar } from "../lib/routes.js";
+import { ACHIEVEMENTS } from "../lib/achievements.js";
+export const statusCommand = defineCommand({
+    meta: { name: "status", description: "Show current status" },
+    run: async () => {
+        const config = await loadConfig();
+        const ghAuth = await isGhAuthenticated();
+        const unpushed = await hasUnpushedCommits(config.local_path);
+        const pagesUrl = getPagesUrl(config) ?? "(private repo - use `stp open` for local view)";
+        const records = await readRecords(getCsvPath(config));
+        const totalKm = records.reduce((s, r) => s + r.distance_km, 0);
+        const totalMin = records.reduce((s, r) => s + r.time_min, 0);
+        const totalHours = Math.floor(totalMin / 60);
+        const remainMin = Math.round(totalMin % 60);
+        let statusText = `GitHub repo: ${config.repo}\n` +
+            `Local path:  ${config.local_path}\n` +
+            `Pages URL:   ${pagesUrl}\n` +
+            `Speed:       ${config.default_speed} km/h\n` +
+            `Weight:      ${config.weight_kg !== null ? config.weight_kg + " kg" : "not set"}\n` +
+            `\n` +
+            `Total walks: ${records.length}\n` +
+            `Distance:    ${totalKm.toFixed(2)} km\n` +
+            `Time:        ${totalHours}h ${remainMin}m\n`;
+        // Journey
+        const journey = config.journey;
+        const route = journey ? getRoute(journey.route_id) : undefined;
+        if (journey && route) {
+            const journeyKm = Math.max(0, totalKm - journey.started_km);
+            const progress = getProgress(route, journeyKm);
+            statusText +=
+                `\n` +
+                    `Journey:     ${route.from} \u2192 ${route.to}\n` +
+                    `Progress:    ${progressBar(progress.percent)} ${progress.percent.toFixed(1)}%\n` +
+                    `             ${Math.floor(progress.walkedKm)} / ${route.total_km.toLocaleString()} km`;
+            if (progress.next) {
+                statusText += `\nNext stop:   ${progress.next.name} (${Math.ceil(progress.nextDistance)} km)`;
+            }
+            statusText += "\n";
+        }
+        // Achievements
+        const unlocked = config.achievements ?? {};
+        const unlockedCount = Object.keys(unlocked).length;
+        statusText += `\nAchievements: ${unlockedCount} / ${ACHIEVEMENTS.length}`;
+        statusText +=
+            `\n\n` +
+                `Unpushed:    ${unpushed ? "yes - run \`stp sync\`" : "no"}\n` +
+                `gh auth:     ${ghAuth ? "authenticated" : "NOT authenticated"}`;
+        consola.box(statusText);
+    },
+});

package/dist/commands/sync.js

@@ -0,0 +1,25 @@
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { loadConfig } from "../lib/config.js";
+import { gitPush, hasUnpushedCommits } from "../lib/git.js";
+export const syncCommand = defineCommand({
+    meta: { name: "sync", description: "Push unpushed commits to GitHub" },
+    run: async () => {
+        const config = await loadConfig();
+        const cwd = config.local_path;
+        if (!(await hasUnpushedCommits(cwd))) {
+            consola.info("Nothing to push. Already in sync.");
+            return;
+        }
+        consola.start("Pushing to GitHub...");
+        try {
+            await gitPush(cwd);
+            consola.success("Pushed successfully.");
+        }
+        catch (e) {
+            const err = e;
+            consola.error(`Push failed: ${err.message}`);
+            process.exit(1);
+        }
+    },
+});