@tangle-network/starter-foundry 0.5.4 → 0.7.2

package/registry/layers/framework/streamlit-advanced/files/app.py

@@ -0,0 +1,76 @@
+from datetime import date, timedelta
+
+import pandas as pd
+import plotly.express as px
+import streamlit as st
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="APP_")
+
+    service_name: str = Field(default="{{serviceName}}")
+    headline: str = Field(default="{{headline}}")
+    subheadline: str = Field(default="{{subheadline}}")
+
+
+settings = Settings()
+
+st.set_page_config(
+    page_title=settings.headline,
+    page_icon=":bar_chart:",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+
+@st.cache_data(ttl=600)
+def load_timeseries(days: int) -> pd.DataFrame:
+    today = date.today()
+    index = [today - timedelta(days=days - i - 1) for i in range(days)]
+    values = [100 + i * 1.3 + (i % 7) * 3 for i in range(days)]
+    return pd.DataFrame({"date": index, "metric": values})
+
+
+with st.sidebar:
+    st.title(settings.headline)
+    st.caption(settings.subheadline)
+    window = st.slider("Window (days)", min_value=14, max_value=180, value=60, step=7)
+    st.divider()
+    st.write("Service: ", settings.service_name)
+
+
+tab_overview, tab_detail, tab_about = st.tabs(["Overview", "Detail", "About"])
+
+with tab_overview:
+    st.header("Overview")
+    df = load_timeseries(window)
+    col_a, col_b, col_c = st.columns(3)
+    col_a.metric("Latest", f"{df['metric'].iloc[-1]:.1f}")
+    col_a.caption("Most recent sample")
+    col_b.metric("Mean", f"{df['metric'].mean():.1f}")
+    col_b.caption(f"Over last {window} days")
+    col_c.metric("Delta", f"{df['metric'].iloc[-1] - df['metric'].iloc[0]:+.1f}")
+    col_c.caption("First-to-last drift")
+
+    fig = px.line(df, x="date", y="metric", title="Metric over time")
+    fig.update_layout(margin=dict(l=0, r=0, t=40, b=0))
+    st.plotly_chart(fig, use_container_width=True)
+
+with tab_detail:
+    st.header("Detail")
+    st.dataframe(load_timeseries(window), use_container_width=True)
+
+with tab_about:
+    st.header("About")
+    st.markdown(
+        """
+        This is the multipage entrypoint. Additional pages live under `pages/`
+        and Streamlit auto-registers them in the sidebar in numeric order.
+
+        - Caching: `@st.cache_data` for DataFrames, `@st.cache_resource` for connections.
+        - Settings: `Settings` reads `APP_*` env vars via pydantic-settings.
+        - Theme: `.streamlit/config.toml`.
+        """
+    )

package/registry/layers/framework/streamlit-advanced/manifest.json

@@ -0,0 +1,60 @@
+{
+  "id": "streamlit-advanced",
+  "description": "Streamlit advanced framework layer: multipage app shell with sidebar, tabs, caching, Plotly charts, and a typed pydantic-settings module.",
+  "appliesTo": ["streamlit-advanced"],
+  "files": [
+    { "source": "files/app.py", "target": "app.py" },
+    { "source": "files/analysis.py", "target": "pages/1_analysis.py" },
+    { "source": "files/README.md", "target": "README.md" },
+    { "source": "files/.env.example", "target": ".env.example" }
+  ],
+  "buildHints": {
+    "whenToUse": "Data dashboards, internal analytics tools, ML model explorers, or any product where the primary surface is a Python-driven web UI backed by pandas/plotly data.",
+    "firstSteps": [
+      "Run `pip install -r requirements.txt` then `streamlit run app.py` — the app serves on port 8501 with the Overview/Detail/About tab layout immediately visible.",
+      "All settings (headline, service name, port) are read from `APP_*` env vars via the `Settings` class in `app.py`; set them in a `.env` file or your deployment environment.",
+      "Add new pages by dropping `pages/<number>_<Title>.py` files — Streamlit auto-registers them in the sidebar in numeric order; follow the pattern in `pages/1_analysis.py`.",
+      "Heavy data loads should use `@st.cache_data(ttl=...)` for DataFrames and `@st.cache_resource` for database connections — both are demonstrated in `app.py`.",
+      "Run `node validate-streamlit.mjs` to verify the scaffold is wired correctly before deploying."
+    ],
+    "gotchas": [
+      "`st.set_page_config()` must be the first Streamlit call in every page file, including each file under `pages/`; calling anything else first raises a StreamlitAPIException.",
+      "`pydantic-settings` v2 requires `model_config = SettingsConfigDict(env_prefix=...)` — the deprecated inner `class Config` style raises warnings and may fail strict linters.",
+      "Streamlit re-runs the entire script on every widget interaction; keep heavy computation inside `@st.cache_data` / `@st.cache_resource` to avoid re-fetching on each slider move.",
+      "The `.streamlit/config.toml` `port` placeholder (`{{port}}`) must be replaced at compose time — leaving the literal string causes Streamlit to fail to parse the config."
+    ],
+    "architectureNotes": [
+      "Each file under `pages/` is an independent script; do not import from `app.py` — share helpers via a separate module (e.g. `lib/data.py`) imported by both.",
+      "The `Settings` class is the single source of truth for env-driven config; extend it rather than scattering `os.getenv` calls across page files."
+    ],
+    "placeholders": [
+      {
+        "path": "app.py",
+        "description": "Bootstrap dashboard with synthetic time-series data. Replace `load_timeseries` with real data fetching (DB query, API call, CSV read). Keep the Settings class, sidebar layout, and tab structure."
+      },
+      {
+        "path": "pages/1_analysis.py",
+        "description": "Bootstrap analysis page with synthetic segment data. Replace `load_sample` with a real query. Rename the file to reflect the actual page topic."
+      }
+    ]
+  },
+  "contextHints": {
+    "commands": [
+      "pip install -r requirements.txt",
+      "streamlit run app.py --server.port 8501",
+      "node validate-streamlit.mjs"
+    ],
+    "entrypoints": [
+      "app.py",
+      "pages/1_analysis.py"
+    ],
+    "preview": {
+      "port": "8501",
+      "path": "/"
+    },
+    "extensionPoints": [
+      "pages/",
+      "app.py"
+    ]
+  }
+}

package/registry/layers/framework/tangle-blueprint/files/foundry.toml

@@ -15,3 +15,11 @@ remappings_version = false
 
 [dependencies]
 tnt-core = "0.10.6"
+
+# forge lint — match forge-foundation's ruleset so blueprint scaffolds
+# don't trip the VB "lint" layer on info-severity naming conventions.
+# See registry/layers/framework/forge-foundation/files/foundry.toml for
+# the shipped-incident rationale (R1: 14/14 dex-swap failures).
+[lint]
+severity = ["high", "med", "gas"]
+ignore = ["contracts/test/**/*", "contracts/script/**/*"]

package/registry/layers/framework/tangle-blueprint/files/lib.rs

@@ -1,21 +1,27 @@
+use blueprint_sdk::Job;
 use blueprint_sdk::Router;
+use blueprint_sdk::alloy::primitives::Address;
+use blueprint_sdk::alloy::sol;
+use blueprint_sdk::tangle::TangleLayer;
 use blueprint_sdk::tangle::extract::{Caller, TangleArg, TangleResult};
-use serde::{Deserialize, Serialize};
 
 /// Job ID for the {{jobName}} job.
 pub const JOB_ID: u8 = 0;
 
-/// Input payload sent from the Tangle contract.
-#[derive(Clone, Debug, Default, Deserialize, Serialize)]
-pub struct JobRequest {
-    pub input: String,
-}
+// Solidity ABI-compatible input + output types. Tangle jobs receive
+// ABI-encoded `bytes calldata` on-chain and emit `bytes` back — every
+// `TangleArg<T>` / `TangleResult<T>` payload must therefore be a
+// `SolValue`. The `sol!` macro generates both the Rust struct and the
+// SolValue/SolStruct impls in one declaration.
+sol! {
+    struct JobRequest {
+        string input;
+    }
 
-/// Output payload returned back to the caller.
-#[derive(Clone, Debug, Default, Deserialize, Serialize)]
-pub struct JobResponse {
-    pub result: String,
-    pub operator: String,
+    struct JobResponse {
+        string result;
+        string operator;
+    }
 }
 
 /// Handles the {{jobName}} job.
@@ -27,14 +33,22 @@ pub async fn handle_job(
 
     TangleResult(JobResponse {
         result,
-        operator: caller.to_string(),
+        // `caller` is `[u8; 20]` (the raw EVM-address bytes). Wrap in
+        // `Address` to render as the canonical 0x-prefixed EIP-55
+        // checksummed hex string.
+        operator: Address::from(caller).to_checksum(None),
     })
 }
 
 /// Router that maps job IDs to handlers.
+///
+/// `TangleLayer` is required when the handler uses Tangle extractors
+/// (`Caller`, `TangleArg<T>`, etc.) — it translates a raw `JobCall`'s
+/// encoded payload + metadata into the concrete extractor types. Plain
+/// `async fn() -> impl IntoJobResult` handlers don't need it.
 #[must_use]
 pub fn router() -> Router {
-    Router::new().route(JOB_ID, handle_job)
+    Router::new().route(JOB_ID, handle_job.layer(TangleLayer))
 }
 
 #[cfg(test)]
@@ -43,12 +57,12 @@ mod tests {
 
     #[tokio::test]
     async fn job_produces_output() {
-        let caller = [0u8; 32].into();
+        let caller = Caller([0u8; 20]);
         let request = JobRequest {
             input: "demo".to_string(),
         };
 
-        let result = handle_job(Caller(caller), TangleArg(request)).await;
+        let result = handle_job(caller, TangleArg(request)).await;
         assert!(result.0.result.contains("{{jobName}}"));
         assert!(result.0.result.ends_with("demo"));
     }

package/registry/layers/framework/tauri-menubar/README.md

@@ -0,0 +1,54 @@
+# tauri-menubar
+
+Tauri 2 menu-bar popover scaffold. A tray icon anchors a 320×400 floating panel that shows on left-click and hides on blur — same interaction model as Raycast or 1Password mini.
+
+## Quick start
+
+```sh
+pnpm install
+cargo tauri dev        # Vite hot-reload + Tauri webview wrapper
+```
+
+Click the tray icon in the menu bar to toggle the popover.
+
+## Key files
+
+| File | Purpose |
+|------|---------|
+| `src/App.tsx` | Popover UI — search input + scrollable action list |
+| `src-tauri/src/lib.rs` | TrayIconBuilder, positioner wiring, hide-on-blur handler |
+| `src-tauri/tauri.conf.json` | Window config (no decorations, always-on-top, 320×400) |
+| `src-tauri/Cargo.toml` | Rust deps: tauri + tray-icon, positioner, global-shortcut |
+
+## Adding Tauri commands
+
+Wire backend logic in `src-tauri/src/lib.rs`:
+
+```rust
+#[tauri::command]
+async fn my_action() -> String {
+    "done".into()
+}
+// add to Builder:
+// .invoke_handler(tauri::generate_handler![my_action])
+```
+
+Call from `src/App.tsx`:
+
+```ts
+import { invoke } from '@tauri-apps/api/core';
+const result = await invoke<string>('my_action');
+```
+
+## Before distributing
+
+```sh
+cargo tauri icon assets/icon-1024.png   # generates full icon set in src-tauri/icons/
+cargo tauri build                       # notarize on macOS before publishing
+```
+
+## Notes
+
+- macOS: `ActivationPolicy::Accessory` (set in `lib.rs`) hides the dock icon. Comment it out temporarily if you need Xcode debugger attach.
+- Windows hide-on-blur: clicking the tray icon fires `Focused(false)` before the click handler runs; add a ~100ms debounce if you see a show/hide flicker.
+- `src-tauri/build.rs` must call `tauri_build::build()` — removing it breaks Tauri's code-gen step.

package/registry/layers/framework/tauri-menubar/files/App.tsx

@@ -0,0 +1,65 @@
+import { useEffect, useRef, useState } from "react";
+
+// Menu-bar popover is intentionally simple: a search row on top, a
+// scrollable list of actions below. Keep the surface under 320x400 —
+// anything taller starts feeling like a real window instead of a
+// dismissable panel.
+type Action = {
+  id: string;
+  title: string;
+  hint: string;
+};
+
+const SEED: Action[] = [
+  { id: "new-note", title: "New quick note", hint: "Cmd+N" },
+  { id: "search-docs", title: "Search documentation", hint: "Cmd+K" },
+  { id: "toggle-focus", title: "Toggle focus mode", hint: "Cmd+F" },
+  { id: "open-settings", title: "Preferences", hint: "Cmd+," },
+];
+
+export default function App() {
+  const [query, setQuery] = useState("");
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    // Popover panels should focus the query row on every show so the
+    // user can type immediately without clicking.
+    inputRef.current?.focus();
+  }, []);
+
+  const filtered = SEED.filter((action) =>
+    action.title.toLowerCase().includes(query.toLowerCase()),
+  );
+
+  return (
+    <main className="popover">
+      <header className="popover__header">
+        <h1>{{headline}}</h1>
+        <p>{{subheadline}}</p>
+      </header>
+      <input
+        ref={inputRef}
+        className="popover__query"
+        placeholder="Type to search actions…"
+        value={query}
+        onChange={(event) => setQuery(event.target.value)}
+      />
+      <ul className="popover__list">
+        {filtered.map((action) => (
+          <li key={action.id} className="popover__row">
+            <span>{action.title}</span>
+            <kbd>{action.hint}</kbd>
+          </li>
+        ))}
+        {filtered.length === 0 && (
+          <li className="popover__row popover__row--empty">
+            No actions match "{query}"
+          </li>
+        )}
+      </ul>
+      <footer className="popover__footer">
+        Wire Tauri commands in src-tauri/src/lib.rs to dispatch these actions.
+      </footer>
+    </main>
+  );
+}

package/registry/layers/framework/tauri-menubar/files/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "{{crateName}}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "{{crateName}}_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = ["tray-icon"] }
+tauri-plugin-positioner = "2"
+tauri-plugin-global-shortcut = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

package/registry/layers/framework/tauri-menubar/files/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/registry/layers/framework/tauri-menubar/files/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{{headline}}</title>
+    <link rel="stylesheet" href="/src/styles.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/registry/layers/framework/tauri-menubar/files/lib.rs

@@ -0,0 +1,75 @@
+// Menu-bar popover setup. Two responsibilities:
+//   1. Build the tray icon and on left-click, show the popover anchored
+//      under the icon using tauri-plugin-positioner's TrayCenter.
+//   2. On window blur, hide the popover so it behaves like a native menu.
+//
+// Hide-on-blur MUST be debounced on Windows because clicking the tray
+// icon itself fires a focus-lost event before the click handler runs,
+// which would create a show-then-immediately-hide loop.
+
+use tauri::{
+    menu::{Menu, MenuItem},
+    tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
+    Manager, WindowEvent,
+};
+use tauri_plugin_positioner::{Position, WindowExt};
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_positioner::init())
+        .plugin(tauri_plugin_global_shortcut::Builder::new().build())
+        .setup(|app| {
+            // macOS: hide from the dock so only the menu-bar icon shows.
+            #[cfg(target_os = "macos")]
+            app.set_activation_policy(tauri::ActivationPolicy::Accessory);
+
+            let quit = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
+            let menu = Menu::with_items(app, &[&quit])?;
+
+            let _tray = TrayIconBuilder::with_id("main")
+                .icon(app.default_window_icon().unwrap().clone())
+                .menu(&menu)
+                .menu_on_left_click(false)
+                .on_menu_event(|app, event| {
+                    if event.id.as_ref() == "quit" {
+                        app.exit(0);
+                    }
+                })
+                .on_tray_icon_event(|tray, event| {
+                    tauri_plugin_positioner::on_tray_event(tray.app_handle(), &event);
+                    if let TrayIconEvent::Click {
+                        button: MouseButton::Left,
+                        button_state: MouseButtonState::Up,
+                        ..
+                    } = event
+                    {
+                        if let Some(window) = tray.app_handle().get_webview_window("main") {
+                            let _ = window.move_window(Position::TrayCenter);
+                            if window.is_visible().unwrap_or(false) {
+                                let _ = window.hide();
+                            } else {
+                                let _ = window.show();
+                                let _ = window.set_focus();
+                            }
+                        }
+                    }
+                })
+                .build(app)?;
+            Ok(())
+        })
+        .on_window_event(|window, event| {
+            // Hide-on-blur so the popover dismisses like a native menu.
+            // The `api.prevent_close()` dance on CloseRequested keeps the
+            // process alive when users hit cmd+w instead of quitting.
+            if let WindowEvent::Focused(false) = event {
+                let _ = window.hide();
+            }
+            if let WindowEvent::CloseRequested { api, .. } = event {
+                api.prevent_close();
+                let _ = window.hide();
+            }
+        })
+        .run(tauri::generate_context!())
+        .expect("error while running tauri menu-bar application");
+}

package/registry/layers/framework/tauri-menubar/files/main.rs

@@ -0,0 +1,7 @@
+// Entry point — all logic lives in lib.rs so the binary stays small and
+// the menu-bar setup can be unit-tested without spinning up a window.
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    {{crateName}}_lib::run();
+}

package/registry/layers/framework/tauri-menubar/files/main.tsx

@@ -0,0 +1,14 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App";
+
+const container = document.getElementById("root");
+if (!container) {
+  throw new Error("missing #root");
+}
+
+createRoot(container).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/registry/layers/framework/tauri-menubar/files/styles.css

@@ -0,0 +1,112 @@
+:root {
+  color-scheme: light dark;
+  font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif;
+}
+
+html,
+body,
+#root {
+  margin: 0;
+  padding: 0;
+  width: 320px;
+  height: 400px;
+  overflow: hidden;
+  background: transparent;
+}
+
+/* Popover container: rounded to match macOS vibrancy, subtle border for
+ * light mode, hard edge for Windows dark contexts. */
+.popover {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  background: rgba(255, 255, 255, 0.92);
+  color: #0f172a;
+  border-radius: 12px;
+  border: 1px solid rgba(15, 23, 42, 0.08);
+  box-shadow: 0 16px 32px rgba(15, 23, 42, 0.18);
+  backdrop-filter: saturate(160%) blur(18px);
+}
+
+@media (prefers-color-scheme: dark) {
+  .popover {
+    background: rgba(15, 23, 42, 0.88);
+    color: #f8fafc;
+    border-color: rgba(248, 250, 252, 0.08);
+  }
+}
+
+.popover__header {
+  padding: 12px 14px 8px;
+}
+
+.popover__header h1 {
+  font-size: 13px;
+  margin: 0;
+  font-weight: 600;
+}
+
+.popover__header p {
+  font-size: 11px;
+  margin: 2px 0 0;
+  opacity: 0.7;
+}
+
+.popover__query {
+  margin: 0 12px;
+  padding: 8px 10px;
+  font-size: 13px;
+  border-radius: 8px;
+  border: 1px solid rgba(15, 23, 42, 0.12);
+  background: rgba(255, 255, 255, 0.6);
+  outline: none;
+}
+
+.popover__query:focus {
+  border-color: #6366f1;
+  box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.15);
+}
+
+.popover__list {
+  flex: 1;
+  overflow-y: auto;
+  list-style: none;
+  padding: 6px;
+  margin: 8px 6px 0;
+}
+
+.popover__row {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 6px 10px;
+  border-radius: 6px;
+  font-size: 13px;
+  cursor: pointer;
+}
+
+.popover__row:hover {
+  background: rgba(99, 102, 241, 0.1);
+}
+
+.popover__row--empty {
+  opacity: 0.6;
+  cursor: default;
+  justify-content: center;
+}
+
+.popover__row kbd {
+  font-size: 11px;
+  font-family: ui-monospace, SFMono-Regular, monospace;
+  background: rgba(15, 23, 42, 0.08);
+  padding: 2px 6px;
+  border-radius: 4px;
+}
+
+.popover__footer {
+  padding: 8px 14px 12px;
+  font-size: 10px;
+  opacity: 0.55;
+  border-top: 1px solid rgba(15, 23, 42, 0.06);
+}

package/registry/layers/framework/tauri-menubar/files/tauri.conf.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
+  "productName": "{{projectName}}",
+  "version": "0.1.0",
+  "identifier": "com.starterfoundry.{{packageName}}",
+  "build": {
+    "frontendDist": "../dist",
+    "devUrl": "http://localhost:1420",
+    "beforeDevCommand": "vite",
+    "beforeBuildCommand": "vite build"
+  },
+  "app": {
+    "windows": [
+      {
+        "label": "main",
+        "title": "{{projectName}}",
+        "width": 320,
+        "height": 400,
+        "resizable": false,
+        "decorations": false,
+        "alwaysOnTop": true,
+        "skipTaskbar": true,
+        "visible": false,
+        "transparent": true,
+        "focus": true
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "macOS": {
+      "minimumSystemVersion": "10.15"
+    }
+  }
+}

package/registry/layers/framework/tauri-menubar/files/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "jsx": "react-jsx",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"]
+}

package/registry/layers/framework/tauri-menubar/files/vite.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+// Tauri menu-bar popovers ship a tiny bundle — the panel is 320x400 and
+// should open in <100ms. Disable sourcemaps in prod, keep a fixed dev
+// port so `cargo tauri dev` can point its webview at it.
+export default defineConfig({
+  plugins: [react()],
+  clearScreen: false,
+  server: {
+    port: 1420,
+    strictPort: true,
+  },
+  build: {
+    target: "esnext",
+    sourcemap: false,
+  },
+});