Add Gemini CLI tasks template for matifali namespace

- Create new matifali namespace with Gemini CLI tasks template
- Template includes Kubernetes deployment with Gemini CLI integration
- Supports masked GEMINI_API_KEY parameter for secure API key input
- Includes automated task execution and reporting capabilities
- Based on existing Claude Code template structure
- Includes comprehensive README and test files

Co-authored-by: ioAtif <[email protected]>

Author: blink-so[bot]

registry/matifali/tasks/gemini-cli/README.md

@@ -0,0 +1,103 @@
+---
+display_name: Gemini CLI Tasks
+description: A Kubernetes workspace template with Gemini CLI for AI-powered coding tasks
+icon: ../../../../.icons/gemini.svg
+verified: false
+tags: [kubernetes, gemini, ai, google, tasks, node]
+---
+
+# Gemini CLI Tasks Template
+
+A complete Kubernetes workspace template that integrates Google's Gemini CLI for AI-powered coding assistance and automated task execution.
+
+## Features
+
+- **Kubernetes Deployment**: Full workspace running on Kubernetes with persistent storage
+- **Gemini CLI Integration**: Pre-configured with Google's Gemini AI models
+- **Task Automation**: Built-in support for automated task execution and reporting
+- **Node.js Environment**: Ready-to-use Node.js development environment
+- **Secure API Key Management**: Masked input for Gemini API key
+- **Interactive Terminal**: Direct terminal access for manual Gemini CLI usage
+
+## Prerequisites
+
+- Kubernetes cluster with Coder deployed
+- Gemini API key from Google AI Studio
+- Persistent volume support in your cluster
+
+## Parameters
+
+### GEMINI_API_KEY (Required)
+- **Type**: String (masked input)
+- **Description**: Your Gemini API key for accessing Google's AI models
+- **Sensitive**: Yes
+- **Mutable**: Yes
+
+Get your API key from [Google AI Studio](https://aistudio.google.com/app/apikey).
+
+### AI Prompt (Optional)
+- **Type**: String
+- **Description**: Task prompt for automated Gemini execution
+- **Mutable**: Yes
+- **Default**: Empty (interactive mode)
+
+## Usage
+
+### Interactive Mode
+
+Leave the "AI Prompt" parameter empty to use Gemini CLI interactively:
+
+1. Open the Terminal app in your workspace
+2. Run `gemini` to start an interactive session
+3. Ask questions or request coding assistance
+
+### Automated Task Mode
+
+Provide a task prompt to enable automated execution:
+
+1. Set the "AI Prompt" parameter with your task description
+2. Gemini will automatically execute the task on workspace startup
+3. View task progress in the Coder UI
+
+## Example Prompts
+
+- "Create a simple Express.js API with user authentication"
+- "Set up a React application with TypeScript and Tailwind CSS"
+- "Write unit tests for the existing code in this repository"
+- "Refactor the code to follow best practices and add documentation"
+
+## Security Considerations
+
+- API keys are stored securely and masked in the UI
+- YOLO mode is disabled by default (requires manual approval for tool calls)
+- Workspace runs with non-root user (UID 1000)
+- Network policies can be applied to restrict external access
+
+## Resources
+
+- **CPU**: 250m requests, 2 cores limit
+- **Memory**: 512Mi requests, 4Gi limit
+- **Storage**: 10Gi persistent volume
+
+## Troubleshooting
+
+### Gemini CLI Not Found
+The template automatically installs Node.js and npm. If Gemini CLI is not available, check the startup logs in the agent.
+
+### API Key Issues
+Ensure your Gemini API key is valid and has the necessary permissions. You can test it manually by running:
+```bash
+export GEMINI_API_KEY="your-key-here"
+gemini "Hello, can you help me?"
+```
+
+### Task Reporting Not Working
+Make sure the Coder Login module is properly configured and the workspace has network access to the Coder server.
+
+## Support
+
+For issues with this template, please contact the template maintainer or file an issue in the Coder registry repository.
+
+## Version History
+
+- **1.0.0**: Initial release with basic Gemini CLI integration

registry/matifali/tasks/gemini-cli/main.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from "bun:test";
+import { runTerraformInit, runTerraformPlan, TerraformPlan } from "../../test";
+
+describe("gemini-cli", async () => {
+  await runTerraformInit(import.meta.dir);
+
+  describe("plan", () => {
+    it("default", async () => {
+      const plan: TerraformPlan = await runTerraformPlan(import.meta.dir, {
+        /// Parameters
+        gemini_api_key: "test-api-key-12345",
+        ai_prompt: "Create a simple Node.js application",
+      });
+      expect(plan.resource_changes).toHaveLength(4);
+      expect(plan.resource_changes).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            type: "coder_agent",
+            change: expect.objectContaining({
+              actions: ["create"],
+            }),
+          }),
+          expect.objectContaining({
+            type: "kubernetes_deployment",
+            change: expect.objectContaining({
+              actions: ["create"],
+            }),
+          }),
+          expect.objectContaining({
+            type: "kubernetes_persistent_volume_claim",
+            change: expect.objectContaining({
+              actions: ["create"],
+            }),
+          }),
+          expect.objectContaining({
+            type: "coder_app",
+            change: expect.objectContaining({
+              actions: ["create"],
+            }),
+          }),
+        ])
+      );
+    });
+
+    it("validates gemini api key parameter", async () => {
+      const plan: TerraformPlan = await runTerraformPlan(import.meta.dir, {
+        gemini_api_key: "sk-test-key",
+        ai_prompt: "",
+      });
+      
+      // Check that the agent has the correct environment variables
+      const agent = plan.resource_changes.find(
+        (resource) => resource.type === "coder_agent"
+      );
+      expect(agent?.change?.after?.env).toMatchObject({
+        GEMINI_API_KEY: "sk-test-key",
+        CODER_MCP_GEMINI_API_KEY: "sk-test-key",
+      });
+    });
+
+    it("validates ai prompt parameter", async () => {
+      const plan: TerraformPlan = await runTerraformPlan(import.meta.dir, {
+        gemini_api_key: "test-key",
+        ai_prompt: "Write a Python script",
+      });
+      
+      // Check that the agent has the correct task prompt
+      const agent = plan.resource_changes.find(
+        (resource) => resource.type === "coder_agent"
+      );
+      expect(agent?.change?.after?.env?.CODER_MCP_GEMINI_TASK_PROMPT).toBe(
+        "Write a Python script"
+      );
+    });
+
+    it("creates kubernetes resources with correct labels", async () => {
+      const plan: TerraformPlan = await runTerraformPlan(import.meta.dir, {
+        gemini_api_key: "test-key",
+        ai_prompt: "",
+      });
+      
+      // Check deployment labels
+      const deployment = plan.resource_changes.find(
+        (resource) => resource.type === "kubernetes_deployment"
+      );
+      expect(deployment?.change?.after?.metadata?.[0]?.labels).toMatchObject({
+        "app.kubernetes.io/name": "coder-workspace",
+        "app.kubernetes.io/part-of": "coder",
+        "com.coder.resource": "true",
+      });
+
+      // Check PVC labels
+      const pvc = plan.resource_changes.find(
+        (resource) => resource.type === "kubernetes_persistent_volume_claim"
+      );
+      expect(pvc?.change?.after?.metadata?.[0]?.labels).toMatchObject({
+        "app.kubernetes.io/name": "coder-pvc",
+        "app.kubernetes.io/part-of": "coder",
+        "com.coder.resource": "true",
+      });
+    });
+
+    it("configures container with correct image and resources", async () => {
+      const plan: TerraformPlan = await runTerraformPlan(import.meta.dir, {
+        gemini_api_key: "test-key",
+        ai_prompt: "",
+      });
+      
+      const deployment = plan.resource_changes.find(
+        (resource) => resource.type === "kubernetes_deployment"
+      );
+      const container = deployment?.change?.after?.spec?.[0]?.template?.[0]?.spec?.[0]?.container?.[0];
+      
+      expect(container?.image).toBe("codercom/enterprise-node:ubuntu");
+      expect(container?.resources?.[0]?.requests).toMatchObject({
+        cpu: "250m",
+        memory: "512Mi",
+      });
+      expect(container?.resources?.[0]?.limits).toMatchObject({
+        cpu: "2",
+        memory: "4Gi",
+      });
+    });
+  });
+});