diff --git a/README.md b/README.md
index 821cf2b..41ccee0 100644
--- a/README.md
+++ b/README.md
@@ -6,11 +6,13 @@ Small Go scraper for the Outward Fandom wiki.
```text
.
+├── cmd/outward-web/main.go # web UI entrypoint
├── cmd/scrappr/main.go # binary entrypoint
├── internal/app # bootstrapping and output writing
├── internal/logx # colored emoji logger
├── internal/model # dataset models
├── internal/scraper # crawl flow, parsing, queueing, retries
+├── internal/webui # embedded web server + static UI
├── go.mod
├── go.sum
└── outward_data.json # generated output
@@ -22,6 +24,10 @@ Small Go scraper for the Outward Fandom wiki.
go run ./cmd/scrappr
```
+```bash
+go run ./cmd/outward-web
+```
+
## What It Does
- Crawls item and crafting pages from `outward.fandom.com`
@@ -32,6 +38,7 @@ go run ./cmd/scrappr
- Stores legacy and portable infobox fields, primary item image URLs, recipes, effects, and raw content tables for later processing
- Saves resumable checkpoints into `.cache/scrape-state.json` on a timer, during progress milestones, and on `Ctrl+C`
- Writes a stable, sorted JSON dataset to `outward_data.json`
+- Serves a local craft-planner UI backed by recipes from `outward_data.json`
## Tuning
diff --git a/cmd/outward-web/main.go b/cmd/outward-web/main.go
new file mode 100644
index 0000000..defd771
--- /dev/null
+++ b/cmd/outward-web/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+ "os"
+
+ "scrappr/internal/logx"
+ "scrappr/internal/webui"
+)
+
+func main() {
+ addr := envOrDefault("SCRAPPR_ADDR", ":8080")
+ dataPath := envOrDefault("SCRAPPR_DATA", "outward_data.json")
+
+ if err := webui.Run(addr, dataPath); err != nil {
+ logx.Eventf("error", "fatal: %v", err)
+ os.Exit(1)
+ }
+}
+
+func envOrDefault(key, fallback string) string {
+ if value := os.Getenv(key); value != "" {
+ return value
+ }
+
+ return fallback
+}
diff --git a/internal/scraper/parse.go b/internal/scraper/parse.go
index de7bde4..09e3bcf 100644
--- a/internal/scraper/parse.go
+++ b/internal/scraper/parse.go
@@ -452,14 +452,26 @@ func (s *Scraper) parseImageURL(doc *goquery.Document) string {
func (s *Scraper) normalizeImageURL(raw string) string {
raw = strings.TrimSpace(raw)
- switch {
- case raw == "":
+ if raw == "" {
return ""
- case strings.HasPrefix(raw, "//"):
- return "https:" + raw
- default:
- return raw
}
+
+ if strings.HasPrefix(raw, "//") {
+ raw = "https:" + raw
+ }
+
+ query := ""
+ if idx := strings.Index(raw, "?"); idx >= 0 {
+ query = raw[idx:]
+ raw = raw[:idx]
+ }
+
+ const scaledMarker = "/revision/latest/scale-to-width-down/"
+ if idx := strings.Index(raw, scaledMarker); idx >= 0 {
+ raw = raw[:idx] + "/revision/latest"
+ }
+
+ return raw + query
}
func (s *Scraper) parseContentTables(doc *goquery.Document) []model.Table {
diff --git a/internal/webui/server.go b/internal/webui/server.go
new file mode 100644
index 0000000..05ce3f3
--- /dev/null
+++ b/internal/webui/server.go
@@ -0,0 +1,227 @@
+package webui
+
+import (
+ "embed"
+ "encoding/json"
+ "fmt"
+ "io/fs"
+ "net/http"
+ "os"
+ "sort"
+ "strings"
+
+ "scrappr/internal/logx"
+ "scrappr/internal/model"
+)
+
+//go:embed static/*
+var staticFiles embed.FS
+
+type Catalog struct {
+ ItemNames []string `json:"item_names"`
+ Items []CatalogItem `json:"items"`
+ Craftables []CraftableEntry `json:"craftables"`
+}
+
+type CatalogItem struct {
+ Name string `json:"name"`
+ URL string `json:"url"`
+ ImageURL string `json:"image_url,omitempty"`
+ Categories []string `json:"categories,omitempty"`
+ ItemType string `json:"item_type,omitempty"`
+}
+
+type CraftableEntry struct {
+ CatalogItem
+ Recipes []model.Recipe `json:"recipes"`
+}
+
+func Run(addr, dataPath string) error {
+ catalog, err := loadCatalog(dataPath)
+ if err != nil {
+ return err
+ }
+
+ staticFS, err := fs.Sub(staticFiles, "static")
+ if err != nil {
+ return err
+ }
+
+ mux := http.NewServeMux()
+ mux.HandleFunc("/", serveStaticFile(staticFS, "index.html", "text/html; charset=utf-8"))
+ mux.HandleFunc("/styles.css", serveStaticFile(staticFS, "styles.css", "text/css; charset=utf-8"))
+ mux.HandleFunc("/app.js", serveStaticFile(staticFS, "app.js", "application/javascript; charset=utf-8"))
+ mux.HandleFunc("/api/catalog", func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodGet {
+ http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+
+ setNoCache(w)
+ w.Header().Set("Content-Type", "application/json; charset=utf-8")
+ if err := json.NewEncoder(w).Encode(catalog); err != nil {
+ logx.Eventf("error", "catalog encode failed: %v", err)
+ }
+ })
+
+ logx.Eventf(
+ "start",
+ "web UI listening on %s using %s (%d craftable items)",
+ displayAddr(addr),
+ dataPath,
+ len(catalog.Craftables),
+ )
+
+ return http.ListenAndServe(addr, mux)
+}
+
+func loadCatalog(dataPath string) (Catalog, error) {
+ file, err := os.Open(dataPath)
+ if err != nil {
+ return Catalog{}, fmt.Errorf("open dataset %s: %w", dataPath, err)
+ }
+ defer file.Close()
+
+ var dataset model.Dataset
+ if err := json.NewDecoder(file).Decode(&dataset); err != nil {
+ return Catalog{}, fmt.Errorf("decode dataset %s: %w", dataPath, err)
+ }
+
+ return buildCatalog(dataset), nil
+}
+
+func buildCatalog(dataset model.Dataset) Catalog {
+ itemNames := make([]string, 0, len(dataset.Items))
+ items := make([]CatalogItem, 0, len(dataset.Items))
+ craftableByName := map[string]*CraftableEntry{}
+ itemByName := map[string]CatalogItem{}
+ seen := map[string]bool{}
+
+ for _, item := range dataset.Items {
+ name := strings.TrimSpace(item.Name)
+ if name != "" && !seen[name] {
+ seen[name] = true
+ itemNames = append(itemNames, name)
+ }
+
+ catalogItem := CatalogItem{
+ Name: item.Name,
+ URL: item.URL,
+ ImageURL: item.ImageURL,
+ Categories: item.Categories,
+ ItemType: item.Infobox["Type"],
+ }
+
+ items = append(items, catalogItem)
+ itemByName[strings.ToLower(strings.TrimSpace(item.Name))] = catalogItem
+ }
+
+ for _, item := range dataset.Items {
+ for _, recipe := range item.Recipes {
+ resultKey := strings.ToLower(strings.TrimSpace(recipe.Result))
+ if resultKey == "" {
+ continue
+ }
+
+ entry := craftableByName[resultKey]
+ if entry == nil {
+ base := itemByName[resultKey]
+ if strings.TrimSpace(base.Name) == "" {
+ base = CatalogItem{
+ Name: recipe.Result,
+ URL: item.URL,
+ ImageURL: item.ImageURL,
+ }
+ }
+
+ entry = &CraftableEntry{
+ CatalogItem: base,
+ }
+ craftableByName[resultKey] = entry
+ }
+
+ if !hasRecipe(entry.Recipes, recipe) {
+ entry.Recipes = append(entry.Recipes, recipe)
+ }
+ }
+ }
+
+ sort.Strings(itemNames)
+ sort.Slice(items, func(i, j int) bool {
+ return strings.ToLower(items[i].Name) < strings.ToLower(items[j].Name)
+ })
+
+ craftables := make([]CraftableEntry, 0, len(craftableByName))
+ for _, entry := range craftableByName {
+ craftables = append(craftables, *entry)
+ }
+ sort.Slice(craftables, func(i, j int) bool {
+ return strings.ToLower(craftables[i].Name) < strings.ToLower(craftables[j].Name)
+ })
+
+ return Catalog{
+ ItemNames: itemNames,
+ Items: items,
+ Craftables: craftables,
+ }
+}
+
+func hasRecipe(existing []model.Recipe, target model.Recipe) bool {
+ for _, recipe := range existing {
+ if recipe.Result != target.Result || recipe.ResultCount != target.ResultCount || recipe.Station != target.Station {
+ continue
+ }
+ if len(recipe.Ingredients) != len(target.Ingredients) {
+ continue
+ }
+
+ match := true
+ for i := range recipe.Ingredients {
+ if recipe.Ingredients[i] != target.Ingredients[i] {
+ match = false
+ break
+ }
+ }
+
+ if match {
+ return true
+ }
+ }
+
+ return false
+}
+
+func displayAddr(addr string) string {
+ if strings.HasPrefix(addr, ":") {
+ return "http://localhost" + addr
+ }
+ if strings.HasPrefix(addr, "http://") || strings.HasPrefix(addr, "https://") {
+ return addr
+ }
+ return "http://" + addr
+}
+
+func serveStaticFile(staticFS fs.FS, name, contentType string) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/" && "/"+name != r.URL.Path {
+ http.NotFound(w, r)
+ return
+ }
+
+ content, err := fs.ReadFile(staticFS, name)
+ if err != nil {
+ http.Error(w, "asset missing", http.StatusInternalServerError)
+ return
+ }
+
+ setNoCache(w)
+ w.Header().Set("Content-Type", contentType)
+ _, _ = w.Write(content)
+ }
+}
+
+func setNoCache(w http.ResponseWriter) {
+ w.Header().Set("Cache-Control", "no-store, no-cache, must-revalidate")
+ w.Header().Set("Pragma", "no-cache")
+ w.Header().Set("Expires", "0")
+}
diff --git a/internal/webui/static/app.js b/internal/webui/static/app.js
new file mode 100644
index 0000000..3d15fde
--- /dev/null
+++ b/internal/webui/static/app.js
@@ -0,0 +1,435 @@
+const state = {
+ catalog: null,
+ itemByKey: new Map(),
+};
+
+const inventoryInput = document.querySelector("#inventory-input");
+const quickItemInput = document.querySelector("#quick-item");
+const quickQtyInput = document.querySelector("#quick-qty");
+const itemList = document.querySelector("#item-list");
+const summaryText = document.querySelector("#summary-text");
+const resultsRoot = document.querySelector("#results");
+const chipsRoot = document.querySelector("#inventory-chips");
+
+document.querySelector("#analyze-btn").addEventListener("click", render);
+document.querySelector("#sample-btn").addEventListener("click", () => {
+ inventoryInput.value = [
+ "Water",
+ "2x Ableroot",
+ "2x Oil",
+ "2x Gravel Beetle",
+ "Linen Cloth",
+ "Seaweed",
+ "Salt",
+ ].join("\n");
+ render();
+});
+document.querySelector("#clear-btn").addEventListener("click", () => {
+ inventoryInput.value = "";
+ quickItemInput.value = "";
+ quickQtyInput.value = "1";
+ render();
+});
+document.querySelector("#add-item").addEventListener("click", addQuickItem);
+quickItemInput.addEventListener("keydown", (event) => {
+ if (event.key === "Enter") {
+ event.preventDefault();
+ addQuickItem();
+ }
+});
+inventoryInput.addEventListener("input", renderInventoryPreview);
+
+bootstrap().catch((error) => {
+ summaryText.textContent = "Failed to load crafting catalog.";
+ resultsRoot.innerHTML = `${escapeHtml(error.message)}
`;
+});
+
+async function bootstrap() {
+ const response = await fetch("/api/catalog");
+ if (!response.ok) {
+ throw new Error(`Catalog request failed with ${response.status}`);
+ }
+
+ state.catalog = await response.json();
+ state.itemByKey = buildItemIndex(state.catalog.items || []);
+ hydrateItemList(state.catalog.item_names || []);
+ summaryText.textContent = `Loaded ${state.catalog.item_names.length} known items and ${state.catalog.craftables.length} craftable entries.`;
+ render();
+}
+
+function buildItemIndex(items) {
+ const index = new Map();
+ for (const item of items) {
+ index.set(normalizeName(item.name), item);
+ }
+ return index;
+}
+
+function hydrateItemList(names) {
+ itemList.innerHTML = names.map((name) => ``).join("");
+}
+
+function addQuickItem() {
+ const name = quickItemInput.value.trim();
+ const qty = Math.max(1, Number.parseInt(quickQtyInput.value || "1", 10) || 1);
+ if (!name) {
+ return;
+ }
+
+ const line = qty > 1 ? `${qty}x ${name}` : name;
+ inventoryInput.value = inventoryInput.value.trim()
+ ? `${inventoryInput.value.trim()}\n${line}`
+ : line;
+
+ quickItemInput.value = "";
+ quickQtyInput.value = "1";
+ render();
+}
+
+function render() {
+ renderInventoryPreview();
+
+ if (!state.catalog) {
+ return;
+ }
+
+ const inventory = parseInventory(inventoryInput.value);
+ const craftable = findCraftableRecipes(state.catalog.craftables, inventory);
+
+ if (!craftable.length) {
+ summaryText.textContent = `No craftable recipes found from ${inventory.totalKinds} inventory item types.`;
+ resultsRoot.innerHTML = `
+
+ Add more ingredients or load the sample inventory to see matching recipes.
+
+ `;
+ return;
+ }
+
+ summaryText.textContent = `${craftable.length} recipe matches from ${inventory.totalKinds} inventory item types.`;
+ resultsRoot.innerHTML = craftable.map(renderRecipeCard).join("");
+ wireResultImages();
+}
+
+function renderInventoryPreview() {
+ const inventory = parseInventory(inventoryInput.value);
+ const entries = Object.values(inventory.byKey).sort((a, b) => a.name.localeCompare(b.name));
+
+ if (!entries.length) {
+ chipsRoot.innerHTML = `No inventory entered yet
`;
+ return;
+ }
+
+ chipsRoot.innerHTML = entries
+ .map((entry) => `${escapeHtml(entry.display)}
`)
+ .join("");
+}
+
+function parseInventory(raw) {
+ const byKey = {};
+ const lines = raw
+ .split("\n")
+ .map((line) => line.trim())
+ .filter(Boolean);
+
+ for (const line of lines) {
+ const parsed = parseStackText(line);
+ if (!parsed.name) {
+ continue;
+ }
+
+ const key = normalizeName(parsed.name);
+ if (!byKey[key]) {
+ byKey[key] = {
+ name: parsed.name,
+ count: 0,
+ display: "",
+ };
+ }
+
+ byKey[key].count += parsed.count;
+ byKey[key].display = `${byKey[key].count}x ${byKey[key].name}`;
+ }
+
+ return {
+ byKey,
+ totalKinds: Object.keys(byKey).length,
+ };
+}
+
+function findCraftableRecipes(items, inventory) {
+ const matches = [];
+
+ for (const item of items) {
+ for (const recipe of item.recipes || []) {
+ if (normalizeName(recipe.result || "") !== normalizeName(item.name || "")) {
+ continue;
+ }
+
+ const requirements = collapseRequirements(recipe.ingredients || []);
+
+ if (!requirements.length) {
+ continue;
+ }
+
+ let maxCrafts = Number.POSITIVE_INFINITY;
+ let canCraft = true;
+
+ for (const requirement of requirements) {
+ const have = availableCountForIngredient(requirement.name, inventory);
+ if (have < requirement.count) {
+ canCraft = false;
+ break;
+ }
+ maxCrafts = Math.min(maxCrafts, Math.floor(have / requirement.count));
+ }
+
+ if (!canCraft) {
+ continue;
+ }
+
+ matches.push({
+ item,
+ recipe,
+ maxCrafts: Number.isFinite(maxCrafts) ? maxCrafts : 0,
+ resultYield: parseResultYield(recipe.result_count),
+ });
+ }
+ }
+
+ return matches.sort((left, right) => {
+ if (right.maxCrafts !== left.maxCrafts) {
+ return right.maxCrafts - left.maxCrafts;
+ }
+ return left.item.name.localeCompare(right.item.name);
+ });
+}
+
+function renderRecipeCard(entry) {
+ const initials = escapeHtml(entry.item.name.slice(0, 2).toUpperCase());
+ const ingredients = (entry.recipe.ingredients || [])
+ .map((ingredient) => `${escapeHtml(ingredient)}`)
+ .join("");
+
+ const canonicalImageUrl = normalizeImageUrl(entry.item.image_url || "");
+ const image = canonicalImageUrl
+ ? `})
`
+ : `${initials}
`;
+
+ const station = entry.recipe.station ? `Station: ${escapeHtml(entry.recipe.station)}` : "Station: Any";
+ const yieldLabel = entry.resultYield > 1 ? `${entry.resultYield}x per craft` : "1x per craft";
+
+ return `
+
+ ${image}
+
+
+
+
+
${station} · ${yieldLabel}
+
+
${entry.maxCrafts} craft${entry.maxCrafts === 1 ? "" : "s"} possible
+
+
${ingredients}
+
Outward Craft Planner
+ Tell me what is in your bag, and I will tell you what you can craft.
+
+ One item per line. Use 2x Linen Cloth if you have more than one.
+
+
+
+
+
+
+
+
+
Craftable Items
+
Loading dataset…
+