feat(projects): added other projects

Co-authored-by: Nuxt Studio <noreply@nuxt.studio>

Author: Type-32

content/projects/facet-api.md

@@ -0,0 +1,111 @@
+---
+title: Facet API
+description: A unified class for managing callbacks and cutting down references to MonoBehaviours.
+seo:
+  title: Facet-api file
+  description: "A unified class for managing callbacks and cutting down references to MonoBehaviours. "
+tags: []
+date: 2025-08-29
+progress: release
+repository:
+  repoUsername: CTRL-Neo-Studios
+  repoName: facet-api
+  showIssues: true
+  showWiki: true
+navigation:
+  icon: i-ic-sharp-api
+---
+
+Facet API is a simple plug-and-pull library for managing your callbacks in C# to avoid annoying external references to other classes or objects.
+
+## Design
+
+This API is designed for Unity and provides a unified interface for managing callbacks between classes.
+
+The main idea is to have a unified interface of access between classes that has functions that needs to be called on either side. For example:
+
+![mermaid-diagram-2026-01-08-204148](/projects/facet-api/mermaid-diagram-2026-01-08-204148.png)
+
+As you can see from the graph, classes are accessing classes to try to access the different functions or variables within them, leading to a spaghetti of references and are sometimes hard to manage and track down.
+
+With FacetAPI, you can unify all the functions and variables you need to access into callbacks:
+
+![mermaid-diagram-2026-01-08-204233](/projects/facet-api/mermaid-diagram-2026-01-08-204233.png)
+
+As you can see, the classes are now only accessing the FacetAPI of the other classes, which is a single point of access to all the functions and variables you need to access. This makes it easier to manage and track down references between classes. This also allows you to easily swap out implementations of the FacetAPI without having to change the references in the other classes. This is especially useful for testing, as you can easily swap out the implementation of the FacetAPI with a mock implementation for testing purposes.
+
+## Usage
+
+The usage itself is pretty simple, per design. Though we are using a name-based system, so you need to be careful with the names of the callbacks you create. (We have error handling for conflicting names, but it is still a good idea to be careful with the names you use.)
+
+What we'd suggest for a workaround of the issue above is to have a class have all the static constant variables of the keywords of callbacks, that way when getting callbacks or creating callbacks you'd have better control over the names you use.
+
+### Creating a Callback
+
+```csharp
+using FacetAPI.Runtime.Core;
+
+// Create API instance
+var api = new FacetApi();
+
+// Create a callback
+var callback = api.CreateCallback<Action<string>>("testCallback");
+
+// Subscribe
+callback.Subscribe(msg => Debug.Log($"Received: {msg}"));
+
+// Invoke
+callback.Invoke("Hello World");
+
+// Watch for condition (async version)
+var cts = new CancellationTokenSource();
+_ = callback.WatchAndInvokeAsync(
+    "Test",
+    () => DateTime.Now.Second % 10 == 0,
+    TimeSpan.FromSeconds(1),
+    cts.Token);
+```
+
+### Getting a Callback
+
+```csharp
+using FacetAPI.Runtime.Core;
+
+// Create and register a callback
+var api = new FacetApi();
+api.CreateCallback<Action<int>>("onScoreChanged");
+
+// Later, fetch it elsewhere in your code
+var scoreCallback = api.Get<Action<int>>("onScoreChanged");
+scoreCallback.Subscribe(score => Debug.Log($"Score changed to {score}"));
+
+// Invoke it
+scoreCallback.Invoke(100);
+```
+
+## Installation
+
+### Unity Package Manager (Recommended)
+
+1. Open the Unity Package Manager (Window > Package Manager)
+2. Click the "+" button in the top-left corner
+3. Select "Add package from git URL..."
+4. Enter the URL of this repository: `https://github.com/CTRL-Neo-Studios/facet-api.git`
+5. Click "Add"
+6. Wait for Unity to download and import the package
+7. Use the package in your scripts by adding `using FacetAPI.Runtime.Core;`
+
+### Manual Installation
+
+1. Clone this repository into your Unity project's `Packages` folder
+2. The package will be automatically recognized by Unity
+3. Use the package in your scripts by adding `using FacetAPI.Runtime.Core;`
+
+## Requirements
+
+- Unity 2021.3 or later
+- .NET Standard 2.1 compatible
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

content/projects/simple-cli.md

@@ -0,0 +1,71 @@
+---
+title: SimpleCLI
+description: "An extremely simple CLI building tool for CSharp projects. "
+seo:
+  title: Simple-cli file
+  description: "An extremely simple CLI building tool for CSharp projects. "
+date: 2025-04-15
+tags: []
+progress: release
+repository:
+  repoUsername: CTRL-Neo-Studios
+  repoName: simple-cli
+  showIssues: true
+  showWiki: true
+navigation:
+  icon: i-lucide-code
+---
+
+An extremely simple CLI building tool for CSharp projects.
+
+## Usage
+
+### Modules
+
+Please check the [Modules Document](https://github.com/CTRL-Neo-Studios/simple-cli/blob/dev/Modules.md).
+
+### Parsing
+
+```csharp
+// Registering and using commands
+var parser = new SimpleCLIParser();
+parser.RegisterCommand(new MyCustomCommand());
+
+// Execute commands
+parser.Execute("echo Hello World --color green");
+parser.Execute("help echo");
+```
+
+### Custom Commands
+
+You can use the `SimpleCLICommand` class to create your own commands. Here is an example of a custom echo command:
+
+```csharp
+public class ExampleCommand : CLICommand
+{
+    public override string Name => "echo";
+    public override string Description => "Echoes the input back to the console";
+    public override string Usage => "echo <message> [-c color]";
+    public override string[] Aliases => new[] { "print" };
+    
+    public override void Execute(CLIArguments args, CLIParser context)
+    {
+        if (args.Arguments.Count == 0)
+            throw new CLIException("No message provided");
+            
+        string message = string.Join(" ", args.Arguments);
+        string color = args.GetFlag("c", "white");
+        
+        context.Output($"<color={color}>{message}</color>");
+    }
+    
+    public override string[] GetAutoCompleteSuggestions(int argIndex, string input)
+    {
+        if (argIndex == 0)
+        {
+            return new[] { "red", "green", "blue", "yellow", "white" };
+        }
+        return base.GetAutoCompleteSuggestions(argIndex, input);
+    }
+}
+```

content/projects/tauri-sqlite-orm.md

@@ -0,0 +1,111 @@
+---
+title: Tauri SQLite ORM
+description: "Simple Drizzle-like ORM Wrapper on top of Tauri V2's SQLite JS API Plugin. "
+seo:
+  title: Tauri-sqlite-orm file
+  description: "Simple Drizzle-like ORM Wrapper on top of Tauri V2's SQLite JS API Plugin. "
+date: 2025-08-26
+tags: []
+progress: alpha
+repository:
+  repoUsername: Type-32
+  repoName: tauri-sqlite-orm
+  showIssues: true
+  showWiki: true
+---
+
+A Drizzle-like TypeScript ORM tailored for Tauri v2's `@tauri-apps/plugin-sql` (SQLite). It provides a simple, type-safe query builder and migration tools to help you manage your database with ease.
+
+### Features
+
+- **Drizzle-like Schema:** Define your database schema using a familiar, chainable API.
+- **Strict Type Inference:** Full TypeScript type safety with no `any` types - nullable columns, custom types, and required/optional fields are accurately inferred.
+- **Type-Safe Query Builder:** Build SQL queries with TypeScript, ensuring type safety and autocompletion.
+- **Relations Support:** Define and query one-to-one, one-to-many, and many-to-many relationships between tables.
+- **Nested Includes:** Load relations of relations with intuitive nested syntax.
+- **Advanced Operators:** Comprehensive set of operators including `ne`, `between`, `notIn`, `ilike`, `startsWith`, `endsWith`, `contains`, and more.
+- **Subquery Support:** Use subqueries in WHERE and SELECT clauses with full type safety.
+- **Aggregate Functions:** Type-safe aggregates like `count`, `sum`, `avg`, `min`, `max`, and SQLite's `groupConcat`.
+- **Query Debugging:** Use `.toSQL()` on any query to inspect generated SQL and parameters.
+- **Safety Features:** Automatic WHERE clause validation for UPDATE/DELETE prevents accidental data loss.
+- **Increment/Decrement:** Atomic increment/decrement operations for safe counter updates.
+- **Better Error Handling:** Custom error classes for clear, actionable error messages.
+- **Simplified Migrations:** Keep your database schema in sync with your application's models using automatic schema detection and migration tools.
+- **Lightweight & Performant:** Designed to be a thin layer over the Tauri SQL plugin, ensuring minimal overhead.
+
+Also, bun is the preferred package manager for developing this library, if you want to contribute.
+
+### Installation
+
+```bash
+bun add @type32/tauri-sqlite-orm @tauri-apps/plugin-sql
+```
+
+Make sure the SQL plugin is registered on the Rust side (see Tauri docs).
+
+### Quick Example
+
+```js
+import Database from '@tauri-apps/plugin-sql'
+import { TauriORM, sqliteTable, int, text, relations } from '@type32/tauri-sqlite-orm'
+
+// Define tables
+const users = sqliteTable('users', {
+  id: int('id').primaryKey().autoincrement(),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+})
+
+const posts = sqliteTable('posts', {
+  id: int('id').primaryKey().autoincrement(),
+  title: text('title').notNull(),
+  content: text('content').notNull(),
+  userId: int('user_id').notNull().references(users, 'id'),
+})
+
+// Define relations
+const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts),
+}))
+
+const postsRelations = relations(posts, ({ one }) => ({
+  user: one(users, {
+    fields: [posts._.columns.userId],
+    references: [users._.columns.id],
+  }),
+}))
+
+// Initialize ORM
+const db = await Database.load('sqlite:mydb.db')
+const orm = new TauriORM(db, {
+  users,
+  usersRelations,
+  posts,
+  postsRelations,
+})
+
+// Run migrations
+await orm.migrate()
+
+// Query with relations
+const usersWithPosts = await orm
+  .select(users)
+  .include({ posts: true })
+  .all()
+```
+
+### Documentation
+
+- [Many-to-Many Relations Guide](https://github.com/Type-32/tauri-sqlite-orm/blob/dev/docs/many-to-many-example.md) - Learn how to implement many-to-many relationships with junction tables
+- [Advanced Queries Guide](https://github.com/Type-32/tauri-sqlite-orm/blob/dev/docs/advanced-queries-example.md) - Learn about `.toSQL()`, aggregates, and subqueries
+- [Error Handling and Safety](https://github.com/Type-32/tauri-sqlite-orm/blob/dev/docs/error-handling-and-safety.md) - Learn about WHERE validation, increment/decrement, and error handling
+
+### Relations
+
+The ORM supports three types of relations:
+
+1. **One-to-One / Many-to-One**: Use `one()` to define a relation where the current table references another table
+2. **One-to-Many**: Use `many()` to define a relation where another table references the current table
+3. **Many-to-Many**: Use `manyToMany()` to define a many-to-many relation through a junction table
+
+See the [many-to-many example](https://github.com/Type-32/tauri-sqlite-orm/blob/dev/docs/many-to-many-example.md) for detailed usage.