@ngxtm/devkit 3.14.0 → 3.16.0

package/skills/linux-shell-scripting/SKILL.md

@@ -1,9 +1,11 @@
 ---
-name: Linux Production Shell Scripts
-description: This skill should be used when the user asks to "create bash scripts", "automate Linux tasks", "monitor system resources", "backup files", "manage users", or "write production shell scripts". It provides ready-to-use shell script templates for system administration.
+name: linux-shell-scripting
+description: "This skill should be used when the user asks to \"create bash scripts\", \"automate Linux tasks\", \"monitor system resources\", \"backup files\", \"manage users\", or \"write production she..."
 metadata:
   author: zebbern
   version: "1.1"
+risk: unknown
+source: community
 ---
 
 # Linux Production Shell Scripts
@@ -502,3 +504,6 @@ Minute(0-59) Hour(0-23) Day(1-31) Month(1-12) Weekday(0-7, 0/7=Sun)
 - Quote variables to handle spaces properly
 - Many scripts require root/sudo privileges
 - Use `bash -x script.sh` for debugging
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/skills/linux-troubleshooting/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: linux-troubleshooting
+description: "Linux system troubleshooting workflow for diagnosing and resolving system issues, performance problems, and service failures."
+source: personal
+risk: safe
+domain: system-administration
+category: granular-workflow-bundle
+version: 1.0.0
+---
+
+# Linux Troubleshooting Workflow
+
+## Overview
+
+Specialized workflow for diagnosing and resolving Linux system issues including performance problems, service failures, network issues, and resource constraints.
+
+## When to Use This Workflow
+
+Use this workflow when:
+- Diagnosing system performance issues
+- Troubleshooting service failures
+- Investigating network problems
+- Resolving disk space issues
+- Debugging application errors
+
+## Workflow Phases
+
+### Phase 1: Initial Assessment
+
+#### Skills to Invoke
+- `bash-linux` - Linux commands
+- `devops-troubleshooter` - Troubleshooting
+
+#### Actions
+1. Check system uptime
+2. Review recent changes
+3. Identify symptoms
+4. Gather error messages
+5. Document findings
+
+#### Commands
+```bash
+uptime
+hostnamectl
+cat /etc/os-release
+dmesg | tail -50
+```
+
+#### Copy-Paste Prompts
+```
+Use @bash-linux to gather system information
+```
+
+### Phase 2: Resource Analysis
+
+#### Skills to Invoke
+- `bash-linux` - Resource commands
+- `performance-engineer` - Performance analysis
+
+#### Actions
+1. Check CPU usage
+2. Analyze memory
+3. Review disk space
+4. Monitor I/O
+5. Check network
+
+#### Commands
+```bash
+top -bn1 | head -20
+free -h
+df -h
+iostat -x 1 5
+```
+
+#### Copy-Paste Prompts
+```
+Use @performance-engineer to analyze system resources
+```
+
+### Phase 3: Process Investigation
+
+#### Skills to Invoke
+- `bash-linux` - Process commands
+- `server-management` - Process management
+
+#### Actions
+1. List running processes
+2. Identify resource hogs
+3. Check process status
+4. Review process trees
+5. Analyze strace output
+
+#### Commands
+```bash
+ps aux --sort=-%cpu | head -10
+pstree -p
+lsof -p PID
+strace -p PID
+```
+
+#### Copy-Paste Prompts
+```
+Use @server-management to investigate processes
+```
+
+### Phase 4: Log Analysis
+
+#### Skills to Invoke
+- `bash-linux` - Log commands
+- `error-detective` - Error detection
+
+#### Actions
+1. Check system logs
+2. Review application logs
+3. Search for errors
+4. Analyze log patterns
+5. Correlate events
+
+#### Commands
+```bash
+journalctl -xe
+tail -f /var/log/syslog
+grep -i error /var/log/*
+```
+
+#### Copy-Paste Prompts
+```
+Use @error-detective to analyze log files
+```
+
+### Phase 5: Network Diagnostics
+
+#### Skills to Invoke
+- `bash-linux` - Network commands
+- `network-engineer` - Network troubleshooting
+
+#### Actions
+1. Check network interfaces
+2. Test connectivity
+3. Analyze connections
+4. Review firewall rules
+5. Check DNS resolution
+
+#### Commands
+```bash
+ip addr show
+ss -tulpn
+curl -v http://target
+dig domain
+```
+
+#### Copy-Paste Prompts
+```
+Use @network-engineer to diagnose network issues
+```
+
+### Phase 6: Service Troubleshooting
+
+#### Skills to Invoke
+- `server-management` - Service management
+- `systematic-debugging` - Debugging
+
+#### Actions
+1. Check service status
+2. Review service logs
+3. Test service restart
+4. Verify dependencies
+5. Check configuration
+
+#### Commands
+```bash
+systemctl status service
+journalctl -u service -f
+systemctl restart service
+```
+
+#### Copy-Paste Prompts
+```
+Use @systematic-debugging to troubleshoot service issues
+```
+
+### Phase 7: Resolution
+
+#### Skills to Invoke
+- `incident-responder` - Incident response
+- `bash-pro` - Fix implementation
+
+#### Actions
+1. Implement fix
+2. Verify resolution
+3. Monitor stability
+4. Document solution
+5. Create prevention plan
+
+#### Copy-Paste Prompts
+```
+Use @incident-responder to implement resolution
+```
+
+## Troubleshooting Checklist
+
+- [ ] System information gathered
+- [ ] Resources analyzed
+- [ ] Logs reviewed
+- [ ] Network tested
+- [ ] Services verified
+- [ ] Issue resolved
+- [ ] Documentation created
+
+## Quality Gates
+
+- [ ] Root cause identified
+- [ ] Fix verified
+- [ ] Monitoring in place
+- [ ] Documentation complete
+
+## Related Workflow Bundles
+
+- `os-scripting` - OS scripting
+- `bash-scripting` - Bash scripting
+- `cloud-devops` - DevOps

package/skills/llm-app-patterns/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: llm-app-patterns
-description: "Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, building agents, or setting up LLM observability."
+description: "Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, buildin..."
+risk: unknown
+source: community
 ---
 
 # 🤖 LLM Application Patterns
@@ -474,7 +476,7 @@ class PromptChain:
 
             # Parse output if needed
             if step.get("parser"):
-                output = step["parser"](output)
+                output = step"parser"
 
             context[step["output_key"]] = output
             results.append({

package/skills/llm-application-dev-ai-assistant/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: llm-application-dev-ai-assistant
 description: "You are an AI assistant development expert specializing in creating intelligent conversational interfaces, chatbots, and AI-powered applications. Design comprehensive AI assistant solutions with natur"
+risk: unknown
+source: community
 ---
 
 # AI Assistant Development

package/skills/llm-application-dev-ai-assistant/resources/implementation-playbook.md

@@ -657,7 +657,7 @@ class FunctionCallingInterface:
         )
         
         # Execute function
-        result = await self.functions[function_name]['function'](**validated_args)
+        result = await self.functions[function_name]'function'
         
         # Return result for LLM to process
         return {

package/skills/llm-application-dev-langchain-agent/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: llm-application-dev-langchain-agent
 description: "You are an expert LangChain agent developer specializing in production-grade AI systems using LangChain 0.1+ and LangGraph."
+risk: unknown
+source: community
 ---
 
 # LangChain/LangGraph Agent Development Expert

package/skills/llm-application-dev-prompt-optimize/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: llm-application-dev-prompt-optimize
 description: "You are an expert prompt engineer specializing in crafting effective prompts for LLMs through advanced techniques including constitutional AI, chain-of-thought reasoning, and model-specific optimizati"
+risk: unknown
+source: community
 ---
 
 # Prompt Optimization

package/skills/llm-evaluation/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: llm-evaluation
-description: Implement comprehensive evaluation strategies for LLM applications using automated metrics, human feedback, and benchmarking. Use when testing LLM performance, measuring AI application quality, or establishing evaluation frameworks.
+description: "Implement comprehensive evaluation strategies for LLM applications using automated metrics, human feedback, and benchmarking. Use when testing LLM performance, measuring AI application quality, or ..."
+risk: unknown
+source: community
 ---
 
 # LLM Evaluation

package/skills/loki-mode/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: loki-mode
-description: Multi-agent autonomous startup system for Claude Code. Triggers on "Loki Mode". Orchestrates 100+ specialized agents across engineering, QA, DevOps, security, data/ML, business operations, marketing, HR, and customer success. Takes PRD to fully deployed, revenue-generating product with zero human intervention. Features Task tool for subagent dispatch, parallel code review with 3 specialized reviewers, severity-based issue triage, distributed task queue with dead letter handling, automatic deployment to cloud providers, A/B testing, customer feedback loops, incident response, circuit breakers, and self-healing. Handles rate limits via distributed state checkpoints and auto-resume with exponential backoff. Requires --dangerously-skip-permissions flag.
+description: "Multi-agent autonomous startup system for Claude Code. Triggers on \"Loki Mode\". Orchestrates 100+ specialized agents across engineering, QA, DevOps, security, data/ML, business operations,..."
+risk: unknown
+source: community
 ---
 
 # Loki Mode - Multi-Agent Autonomous Startup System
@@ -719,3 +721,6 @@ Detailed documentation is split into reference files for progressive loading:
 ---
 
 **Version:** 2.32.0 | **Lines:** ~600 | **Research-Enhanced: Labs + HN Production Patterns**
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/skills/m365-agents-dotnet/SKILL.md

@@ -0,0 +1,295 @@
+---
+name: m365-agents-dotnet
+description: "|"
+  Microsoft 365 Agents SDK for .NET. Build multichannel agents for Teams/M365/Copilot Studio with ASP.NET Core hosting, AgentApplication routing, and MSAL-based auth. Triggers: "Microsoft 365 Agents SDK", "Microsoft.Agents", "AddAgentApplicationOptions", "AgentApplication", "AddAgentAspNetAuthentication", "Copilot Studio client", "IAgentHttpAdapter".
+package: Microsoft.Agents.Hosting.AspNetCore, Microsoft.Agents.Authentication.Msal, Microsoft.Agents.CopilotStudio.Client
+risk: unknown
+source: community
+---
+
+# Microsoft 365 Agents SDK (.NET)
+
+## Overview
+Build enterprise agents for Microsoft 365, Teams, and Copilot Studio using the Microsoft.Agents SDK with ASP.NET Core hosting, agent routing, and MSAL-based authentication.
+
+## Before implementation
+- Use the microsoft-docs MCP to verify the latest APIs for AddAgent, AgentApplication, and authentication options.
+- Confirm package versions in NuGet for the Microsoft.Agents.* packages you plan to use.
+
+## Installation
+
+```bash
+dotnet add package Microsoft.Agents.Hosting.AspNetCore
+dotnet add package Microsoft.Agents.Authentication.Msal
+dotnet add package Microsoft.Agents.Storage
+dotnet add package Microsoft.Agents.CopilotStudio.Client
+dotnet add package Microsoft.Identity.Client.Extensions.Msal
+```
+
+## Configuration (appsettings.json)
+
+```json
+{
+  "TokenValidation": {
+    "Enabled": true,
+    "Audiences": [
+      "{{ClientId}}"
+    ],
+    "TenantId": "{{TenantId}}"
+  },
+  "AgentApplication": {
+    "StartTypingTimer": false,
+    "RemoveRecipientMention": false,
+    "NormalizeMentions": false
+  },
+  "Connections": {
+    "ServiceConnection": {
+      "Settings": {
+        "AuthType": "ClientSecret",
+        "ClientId": "{{ClientId}}",
+        "ClientSecret": "{{ClientSecret}}",
+        "AuthorityEndpoint": "https://login.microsoftonline.com/{{TenantId}}",
+        "Scopes": [
+          "https://api.botframework.com/.default"
+        ]
+      }
+    }
+  },
+  "ConnectionsMap": [
+    {
+      "ServiceUrl": "*",
+      "Connection": "ServiceConnection"
+    }
+  ],
+  "CopilotStudioClientSettings": {
+    "DirectConnectUrl": "",
+    "EnvironmentId": "",
+    "SchemaName": "",
+    "TenantId": "",
+    "AppClientId": "",
+    "AppClientSecret": ""
+  }
+}
+```
+
+## Core Workflow: ASP.NET Core agent host
+
+```csharp
+using Microsoft.Agents.Builder;
+using Microsoft.Agents.Hosting.AspNetCore;
+using Microsoft.Agents.Storage;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddHttpClient();
+builder.AddAgentApplicationOptions();
+builder.AddAgent<MyAgent>();
+builder.Services.AddSingleton<IStorage, MemoryStorage>();
+
+builder.Services.AddControllers();
+builder.Services.AddAgentAspNetAuthentication(builder.Configuration);
+
+WebApplication app = builder.Build();
+
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapGet("/", () => "Microsoft Agents SDK Sample");
+
+var incomingRoute = app.MapPost("/api/messages",
+    async (HttpRequest request, HttpResponse response, IAgentHttpAdapter adapter, IAgent agent, CancellationToken ct) =>
+    {
+        await adapter.ProcessAsync(request, response, agent, ct);
+    });
+
+if (!app.Environment.IsDevelopment())
+{
+    incomingRoute.RequireAuthorization();
+}
+else
+{
+    app.Urls.Add("http://localhost:3978");
+}
+
+app.Run();
+```
+
+## AgentApplication routing
+
+```csharp
+using Microsoft.Agents.Builder;
+using Microsoft.Agents.Builder.App;
+using Microsoft.Agents.Builder.State;
+using Microsoft.Agents.Core.Models;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+public sealed class MyAgent : AgentApplication
+{
+    public MyAgent(AgentApplicationOptions options) : base(options)
+    {
+        OnConversationUpdate(ConversationUpdateEvents.MembersAdded, WelcomeAsync);
+        OnActivity(ActivityTypes.Message, OnMessageAsync, rank: RouteRank.Last);
+        OnTurnError(OnTurnErrorAsync);
+    }
+
+    private static async Task WelcomeAsync(ITurnContext turnContext, ITurnState turnState, CancellationToken ct)
+    {
+        foreach (ChannelAccount member in turnContext.Activity.MembersAdded)
+        {
+            if (member.Id != turnContext.Activity.Recipient.Id)
+            {
+                await turnContext.SendActivityAsync(
+                    MessageFactory.Text("Welcome to the agent."),
+                    ct);
+            }
+        }
+    }
+
+    private static async Task OnMessageAsync(ITurnContext turnContext, ITurnState turnState, CancellationToken ct)
+    {
+        await turnContext.SendActivityAsync(
+            MessageFactory.Text($"You said: {turnContext.Activity.Text}"),
+            ct);
+    }
+
+    private static async Task OnTurnErrorAsync(
+        ITurnContext turnContext,
+        ITurnState turnState,
+        Exception exception,
+        CancellationToken ct)
+    {
+        await turnState.Conversation.DeleteStateAsync(turnContext, ct);
+
+        var endOfConversation = Activity.CreateEndOfConversationActivity();
+        endOfConversation.Code = EndOfConversationCodes.Error;
+        endOfConversation.Text = exception.Message;
+        await turnContext.SendActivityAsync(endOfConversation, ct);
+    }
+}
+```
+
+## Copilot Studio direct-to-engine client
+
+### DelegatingHandler for token acquisition (interactive flow)
+
+```csharp
+using System.Net.Http.Headers;
+using Microsoft.Agents.CopilotStudio.Client;
+using Microsoft.Identity.Client;
+
+internal sealed class AddTokenHandler : DelegatingHandler
+{
+    private readonly SampleConnectionSettings _settings;
+
+    public AddTokenHandler(SampleConnectionSettings settings) : base(new HttpClientHandler())
+    {
+        _settings = settings;
+    }
+
+    protected override async Task<HttpResponseMessage> SendAsync(
+        HttpRequestMessage request,
+        CancellationToken cancellationToken)
+    {
+        if (request.Headers.Authorization is null)
+        {
+            string[] scopes = [CopilotClient.ScopeFromSettings(_settings)];
+
+            IPublicClientApplication app = PublicClientApplicationBuilder
+                .Create(_settings.AppClientId)
+                .WithAuthority(AadAuthorityAudience.AzureAdMyOrg)
+                .WithTenantId(_settings.TenantId)
+                .WithRedirectUri("http://localhost")
+                .Build();
+
+            AuthenticationResult authResponse;
+            try
+            {
+                var account = (await app.GetAccountsAsync()).FirstOrDefault();
+                authResponse = await app.AcquireTokenSilent(scopes, account).ExecuteAsync(cancellationToken);
+            }
+            catch (MsalUiRequiredException)
+            {
+                authResponse = await app.AcquireTokenInteractive(scopes).ExecuteAsync(cancellationToken);
+            }
+
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", authResponse.AccessToken);
+        }
+
+        return await base.SendAsync(request, cancellationToken);
+    }
+}
+```
+
+### Console host with CopilotClient
+
+```csharp
+using Microsoft.Agents.CopilotStudio.Client;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
+
+var settings = new SampleConnectionSettings(
+    builder.Configuration.GetSection("CopilotStudioClientSettings"));
+
+builder.Services.AddHttpClient("mcs").ConfigurePrimaryHttpMessageHandler(() =>
+{
+    return new AddTokenHandler(settings);
+});
+
+builder.Services
+    .AddSingleton(settings)
+    .AddTransient<CopilotClient>(sp =>
+    {
+        var logger = sp.GetRequiredService<ILoggerFactory>().CreateLogger<CopilotClient>();
+        return new CopilotClient(settings, sp.GetRequiredService<IHttpClientFactory>(), logger, "mcs");
+    });
+
+IHost host = builder.Build();
+var client = host.Services.GetRequiredService<CopilotClient>();
+
+await foreach (var activity in client.StartConversationAsync(emitStartConversationEvent: true))
+{
+    Console.WriteLine(activity.Type);
+}
+
+await foreach (var activity in client.AskQuestionAsync("Hello!", null))
+{
+    Console.WriteLine(activity.Type);
+}
+```
+
+## Best Practices
+
+1. Use AgentApplication subclasses to centralize routing and error handling.
+2. Use MemoryStorage only for development; use persisted storage in production.
+3. Enable TokenValidation in production and require authorization on /api/messages.
+4. Keep auth secrets in configuration providers (Key Vault, managed identity, env vars).
+5. Reuse HttpClient from IHttpClientFactory and cache MSAL tokens.
+6. Prefer async handlers and pass CancellationToken to SDK calls.
+
+## Reference Files
+
+| File | Contents |
+| --- | --- |
+| references/acceptance-criteria.md | Import paths, hosting pipeline, Copilot Studio client patterns, anti-patterns |
+
+## Reference Links
+
+| Resource | URL |
+| --- | --- |
+| Microsoft 365 Agents SDK | https://learn.microsoft.com/en-us/microsoft-365/agents-sdk/ |
+| AddAgent API | https://learn.microsoft.com/en-us/dotnet/api/microsoft.agents.hosting.aspnetcore.servicecollectionextensions.addagent?view=m365-agents-sdk |
+| AgentApplication API | https://learn.microsoft.com/en-us/dotnet/api/microsoft.agents.builder.app.agentapplication?view=m365-agents-sdk |
+| Auth configuration options | https://learn.microsoft.com/en-us/microsoft-365/agents-sdk/microsoft-authentication-library-configuration-options |
+| Copilot Studio integration | https://learn.microsoft.com/en-us/microsoft-365/agents-sdk/integrate-with-mcs |
+| GitHub samples | https://github.com/microsoft/agents |
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.