Merge pull request #89 from kinode-dao/hf/change-uqbar-to-kinode

change `uqbar-dao` -> `kinode-dao`

src/apis/kinode_wit.md

@@ -13,20 +13,20 @@ So far, we've written Kinode processes in Rust, Javascript, Go, and Python.
 
 To see exactly how to use WIT to write Kinode processes, see the [My First App](../my_first_app/chapter_1.md) chapter or the [Chess Tutorial](../chess_app/chess_engine.md).
 
-To see `kinode.wit` for itself, see the [file in the GitHub repo](https://github.com/uqbar-dao/kinode-wit/blob/master/kinode.wit).
+To see `kinode.wit` for itself, see the [file in the GitHub repo](https://github.com/kinode-dao/kinode-wit/blob/master/kinode.wit).
 Since this interface applies to all processes, it's one of the places in the OS where breaking changes are most likely to make an impact.
 To that end, the version of the WIT file that a process uses must be compatible with the version of Kinode OS on which it runs. 
 We intend to achieve perfect backwards compatibility upon first major release (1.0.0) of the OS and the WIT file.
 After that point, since processes signal the version of the WIT file they use, subsequent updates can be made without breaking existing processes or needing to change the version they use.
 
 ## Types
 
-[These 14 types](https://github.com/uqbar-dao/kinode-wit/blob/373542a9a94ae61a7d216159f9f7bdf9266cd935/kinode.wit#L8-L103) make up the entirety of the shared type system between processes and the kernel.
+[These 14 types](https://github.com/kinode-dao/kinode-wit/blob/373542a9a94ae61a7d216159f9f7bdf9266cd935/kinode.wit#L8-L103) make up the entirety of the shared type system between processes and the kernel.
 Most types presented here are implemented in the [process standard library](../process_stdlib/overview.md) for ease of use.
 
 ## Functions
 
-[These 15 functions](https://github.com/uqbar-dao/kinode-wit/blob/373542a9a94ae61a7d216159f9f7bdf9266cd935/kinode.wit#L105-L184) are available to processes.
+[These 15 functions](https://github.com/kinode-dao/kinode-wit/blob/373542a9a94ae61a7d216159f9f7bdf9266cd935/kinode.wit#L105-L184) are available to processes.
 They are implemented in the kernel.
 Again, the process standard library makes it such that these functions often don't need to be directly called in processes, but they are always available.
 The functions are generally separated into 4 categories: system utilities, process management, capabilities management, and message I/O.

src/apis/vfs.md

@@ -1,6 +1,6 @@
 # VFS API
 
-Useful helper functions can be found in the [kinode_process_lib](https://github.com/uqbar-dao/process_lib)
+Useful helper functions can be found in the [kinode_process_lib](https://github.com/kinode-dao/process_lib)
 
 The VFS API tries to map over the [std::fs](https://doc.rust-lang.org/std/fs/index.html) calls as directly as possible.
 

src/chess_app/chess_engine.md

@@ -1,7 +1,7 @@
 # In-Depth Guide: Chess App
 
 This guide will walk you through building a very simple chess app on Kinode OS.
-The final result will look like [this](https://github.com/uqbar-dao/kinode/tree/main/modules/chess): chess is in the basic runtime distribution so you can try it yourself.
+The final result will look like [this](https://github.com/kinode-dao/kinode/tree/main/modules/chess): chess is in the basic runtime distribution so you can try it yourself.
 
 To prepare for this tutorial, follow the environment setup guide [here](../my_first_app/chapter_1.md), i.e. [start a fake node](../my_first_app/chapter_1.md#booting-a-fake-kinode-node) and then, in another terminal, run:
 ```bash
@@ -157,7 +157,7 @@ lto = true
 anyhow = "1.0"
 base64 = "0.13"
 bincode = "1.3.3"
-kinode_process_lib = { git = "ssh://[email protected]/uqbar-dao/process_lib.git", tag = "v0.5.4-alpha" }
+kinode_process_lib = { git = "ssh://[email protected]/kinode-dao/process_lib.git", tag = "v0.5.4-alpha" }
 pleco = "0.5"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

src/chess_app/frontend.md

@@ -7,17 +7,17 @@ Creating a web frontend has two parts:
 2. Writing a webpage to interact with the process.
 Here, you'll use React to make a single-page app that displays your current games and allows us to: create new games, resign from games, and make moves on the chess board.
 
-JavaScript and React development aren't in the scope of this tutorial, so you can find that code [here](https://github.com/uqbar-dao/chess-ui).
+JavaScript and React development aren't in the scope of this tutorial, so you can find that code [here](https://github.com/kinode-dao/chess-ui).
 
 The important part of the frontend for the purpose of this tutorial is how to set up those pre-existing files to be built and installed by `kit`.
-When files found in the `ui/` directory, if a `package.json` file is found with a `build:copy` field in `scripts`, `kit` will run that to build the UI (see [here](https://github.com/uqbar-dao/chess-ui/blob/82419ea0e53e6d86d6dc6c8ed7f656c3ab51fdc8/package.json#L10)).
+When files found in the `ui/` directory, if a `package.json` file is found with a `build:copy` field in `scripts`, `kit` will run that to build the UI (see [here](https://github.com/kinode-dao/chess-ui/blob/82419ea0e53e6d86d6dc6c8ed7f656c3ab51fdc8/package.json#L10)).
 The `build:copy` in that file builds the UI and then places the resulting files into the `pkg/ui/` directory where they will be installed by `kit start-package`.
 This allows your process to fetch them from the virtual filesystem, as all files in `pkg/` are mounted.
 See the [VFS API overview](../apis/vfs.md) to see how to use files mounted in `pkg/`.
 
 Get the chess UI files and place them in the proper place (next to `pkg/`):
 ```bash
-git clone https://github.com/uqbar-dao/chess-ui ui
+git clone https://github.com/kinode-dao/chess-ui ui
 ```
 
 Chess will use the `http_server` runtime module to serve a static frontend and receive HTTP requests from it.

src/chess_app/putting_everything_together.md

@@ -32,4 +32,4 @@ There are also three extensions to this tutorial which dive into specific use ca
 - [Payment Integration (using ETH)](./payment.md) [coming soon]
 - [LLM Integration (play chess against the AI!)](./llm.md) [coming soon]
 
-The full code is available [here](https://github.com/uqbar-dao/kinode/tree/main/modules/chess).
+The full code is available [here](https://github.com/kinode-dao/kinode/tree/main/modules/chess).

src/cookbook/file_transfer.md

@@ -28,7 +28,7 @@ Here's a clean template so you have a complete fresh start:
 This guide will use the following `kinode_process_lib` version in `file_transfer/Cargo.toml`:
 
 ```
-kinode_process_lib = { git = "ssh://[email protected]/uqbar-dao/process_lib.git", tag = "v0.5.4-alpha" }
+kinode_process_lib = { git = "ssh://[email protected]/kinode-dao/process_lib.git", tag = "v0.5.4-alpha" }
 ```
 
 Replace the `file_transfer/src/lib.rs` with:

src/databases.md

@@ -58,4 +58,4 @@ println!("rows: {}", rows.len());
 - [SQLite](https://www.sqlite.org/docs.html)
 - [`kinode_process_lib` book entry](./process_stdlib/overview.md)
 - [`kinode_process_lib` docs.rs](https://docs.rs/kinode_process_lib)
-- [`kinode_process_lib`](https://github.com/uqbar-dao/process_lib)
+- [`kinode_process_lib`](https://github.com/kinode-dao/process_lib)

src/install.md

@@ -9,7 +9,7 @@ However, if you are just interested in starting development as fast as possible,
 The recommended method for most users is to use a precompiled binary.
 If you want to make edits to the Kinode core software, see [Build From Source](#build-from-source).
 
-First, get the software itself by downloading a [precompiled release binary](https://github.com/uqbar-dao/kinode/releases).
+First, get the software itself by downloading a [precompiled release binary](https://github.com/kinode-dao/kinode/releases).
 Choose the correct binary for your particular computer architecture and OS. 
 There is no need to download the `simulation-mode` binary — it is used behind the scenes. 
 Extract the `.zip` file and the binary is inside.
@@ -48,7 +48,7 @@ For more information, or debugging, see the [Rust lang install page](https://www
 Clone and set up the repository:
 
 ```bash
-git clone [email protected]:uqbar-dao/kinode.git
+git clone [email protected]:kinode-dao/kinode.git
 
 cd kinode
 mkdir .cargo

src/kit/kit.md

@@ -43,7 +43,7 @@ The first chapter of the [Build and Deploy an App tutorial](../my_first_app/chap
 To get `kit`, run
 
 ```bash
-cargo install --git https://github.com/uqbar-dao/kit
+cargo install --git https://github.com/kinode-dao/kit
 ```
 
 To update, run that same command or
@@ -52,7 +52,7 @@ To update, run that same command or
 kit update
 ```
 
-You can find the source for `kit` at [https://github.com/uqbar-dao/kit](https://github.com/uqbar-dao/kit).
+You can find the source for `kit` at [https://github.com/kinode-dao/kit](https://github.com/kinode-dao/kit).
 
 ## Table of Contents
 

src/my_first_app/chapter_1.md

@@ -25,7 +25,7 @@ Install Rust and the Kinode Development Tools, or `kit`:
 
 ```bash
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-cargo install --git https://github.com/uqbar-dao/kit
+cargo install --git https://github.com/kinode-dao/kit
 ```
 
 ## Creating a New Kinode Package Template

src/process_stdlib/overview.md

@@ -1,20 +1,20 @@
 # Overview
 
-The [process standard library](https://github.com/uqbar-dao/process_lib) is the easiest way to write Rust apps on Kinode OS.
+The [process standard library](https://github.com/kinode-dao/process_lib) is the easiest way to write Rust apps on Kinode OS.
 Documentation can be found [here](https://docs.rs/kinode_process_lib), and the crate lives [here](https://crates.io/crates/kinode_process_lib).
 
 Note that the process lib is under heavy ongoing development.
 Therefore, the best way to use it is by selecting a tag or commit hash from the GitHub repo and using that as the version in your `Cargo.toml` file.
-See [here](https://github.com/uqbar-dao/process_lib/releases) for a list of published versions.
+See [here](https://github.com/kinode-dao/process_lib/releases) for a list of published versions.
 
 In your `Cargo.toml` file, use a version tag like this:
 ```toml
-kinode_process_lib = { git = "https://github.com/uqbar-dao/process_lib.git", tag = "v0.5.4-alpha" }
+kinode_process_lib = { git = "https://github.com/kinode-dao/process_lib.git", tag = "v0.5.4-alpha" }
 ```
 
 To use a specific commit hash, use this:
 ```toml
-kinode_process_lib = { git = "https://github.com/uqbar-dao/process_lib.git", rev = "5305453" }
+kinode_process_lib = { git = "https://github.com/kinode-dao/process_lib.git", rev = "5305453" }
 ```
 
 Make sure to use a recent version of the process_lib while the system is in alpha and very active development.

src/processes.md

@@ -177,6 +177,6 @@ This is a high-level overview of process semantics.
 In practice, processes are combined and shared in **packages**, which are generally synonymous with **apps**.
 
 It's briefly discussed here that processes are compiled to Wasm.
-The details of this are not covered in the Kinode Book, but can be found in the documentation for the [Kinode runtime](https://github.com/uqbar-dao/kinode), which uses [Wasmtime](https://wasmtime.dev/), a WebAssembly runtime, to load, execute, and provide an interface for the subset of Wasm processes that are valid Kinode processes.
-Pragmatically, processes can be compiled using the [`kit` tools](https://github.com/uqbar-dao/kit).
+The details of this are not covered in the Kinode Book, but can be found in the documentation for the [Kinode runtime](https://github.com/kinode-dao/kinode), which uses [Wasmtime](https://wasmtime.dev/), a WebAssembly runtime, to load, execute, and provide an interface for the subset of Wasm processes that are valid Kinode processes.
+Pragmatically, processes can be compiled using the [`kit` tools](https://github.com/kinode-dao/kit).
 The long term goal of the Kinode runtime is to use [WASI](https://wasi.dev/) to provide a secure, sandboxed environment for processes to not only make use of the kernel features described in this document, but also to make full use of the entire WebAssembly ecosystem, including the ability to use sandboxed system calls provided by the host via WASI.

src/quick-start.md

@@ -14,7 +14,7 @@ Otherwise:
 ```
 # Get Rust and `kit` Kinode development tools
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-cargo install --git https://github.com/uqbar-dao/kit
+cargo install --git https://github.com/kinode-dao/kit
 
 # Start two fake nodes, each in a new terminal on ports 8080 and 8081:
 ## First new terminal: