@juancr11/sibu 0.7.0 → 0.9.0

package/bin/modules/workflow-target-planning/workflow-targets.js

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { SIBU_VERSION } from '../version-advisory/index.js';
-import { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from './index.js';
+import { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from './index.js';
 import { sha256 } from '../../shared/hash.js';
 import { removeUndefinedFields } from '../../shared/object.js';
 import { readExistingState } from '../workflow-state-registry/index.js';
-import { getTemplateVersion, readTemplate, readTemplateManifest, renderSkillRouting } from '../template-catalog-rendering/index.js';
+import { getTemplateVersion, readTemplate, readTemplateManifest, renderMcpConfig, renderSkillRouting } from '../template-catalog-rendering/index.js';
 export function getSelectedLanguageSkillsFromState(state) {
     return SELECTABLE_LANGUAGE_SKILLS.filter((skill) => state.selectedLanguageSkills?.includes(skill.id));
 }
@@ -18,12 +18,19 @@ export function getSelectedArchitectureSkillFromState(state) {
 export function getSelectedWorkflowSkillsFromState(state) {
     return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => state.selectedWorkflowSkills?.includes(skill.id));
 }
-export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
+export function getSelectedDatabaseSkillsFromState(state) {
+    return SELECTABLE_DATABASE_SKILLS.filter((skill) => state.selectedDatabaseSkills?.includes(skill.id));
+}
+export function getSelectedMcpServersFromState(state) {
+    return SELECTABLE_MCP_SERVERS.filter((server) => state.selectedMcpServers?.includes(server.id));
+}
+export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
     const skillTargets = new Map();
     const selectedSkills = [
         ...MANDATORY_SKILLS,
         ...selectedLanguageSkills,
         ...selectedFrameworkSkills,
+        ...selectedDatabaseSkills,
         ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []),
         ...selectedWorkflowSkills,
     ];
@@ -41,13 +48,49 @@ export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguag
     }
     return [...skillTargets.values()];
 }
-export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill, selectedWorkflowSkills = []) {
-    return [
+export function getSelectedMcpTargetsForAgents(selectedAgents, selectedMcpServers) {
+    if (!selectedMcpServers.some((server) => server.id === 'github')) {
+        return [];
+    }
+    return selectedAgents.flatMap((agent) => {
+        if (agent.id === 'codex') {
+            return [
+                {
+                    targetRelativePath: '.codex/config.toml',
+                    templateRelativePath: '.codex/config.toml',
+                    agentId: 'codex',
+                },
+            ];
+        }
+        if (agent.id === 'claude') {
+            return [
+                {
+                    targetRelativePath: '.mcp.json',
+                    templateRelativePath: 'mcp/claude/.mcp.json',
+                    agentId: 'claude',
+                },
+            ];
+        }
+        if (agent.id === 'gemini') {
+            return [
+                {
+                    targetRelativePath: '.gemini/settings.json',
+                    templateRelativePath: 'mcp/gemini/settings.json',
+                    agentId: 'gemini',
+                },
+            ];
+        }
+        return [];
+    });
+}
+export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers = []) {
+    const targets = [
         {
             label: 'AGENTS.md',
             targetPath: path.join(rootPath, 'AGENTS.md'),
             templateRelativePath: 'AGENTS.md',
             requiresProjectOverview: true,
+            targetKind: 'agent-support',
         },
         ...selectedAgents.flatMap((agent) => {
             if (!agent.targetRelativePath || !agent.templateRelativePath) {
@@ -59,27 +102,55 @@ export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSki
                     targetPath: path.join(rootPath, agent.targetRelativePath),
                     templateRelativePath: agent.templateRelativePath,
                     requiresProjectOverview: false,
+                    targetKind: 'agent-support',
                 },
             ];
         }),
-        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills).map((skillTarget) => ({
+        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills).map((skillTarget) => ({
             label: skillTarget.targetRelativePath,
             targetPath: path.join(rootPath, skillTarget.targetRelativePath),
             templateRelativePath: skillTarget.templateRelativePath,
             requiresProjectOverview: false,
+            targetKind: 'skill',
         })),
     ];
+    for (const mcpTarget of getSelectedMcpTargetsForAgents(selectedAgents, selectedMcpServers)) {
+        const targetPath = path.join(rootPath, mcpTarget.targetRelativePath);
+        const existingTarget = targets.find((target) => target.targetPath === targetPath);
+        if (existingTarget) {
+            existingTarget.selectedMcpServers = selectedMcpServers;
+            existingTarget.mcpConfigAgentId = mcpTarget.agentId;
+            continue;
+        }
+        targets.push({
+            label: mcpTarget.targetRelativePath,
+            targetPath,
+            templateRelativePath: mcpTarget.templateRelativePath,
+            requiresProjectOverview: false,
+            targetKind: 'mcp-config',
+            mcpConfigAgentId: mcpTarget.agentId,
+            selectedMcpServers,
+        });
+    }
+    return targets;
 }
-export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], }) {
+export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers = [], }) {
     return missingTargets.map((target) => {
         let contents = readTemplate(target.templateRelativePath);
+        if (target.mcpConfigAgentId && (target.selectedMcpServers?.length || selectedMcpServers.length)) {
+            contents = renderMcpConfig({
+                agentId: target.mcpConfigAgentId,
+                baseContents: contents,
+                selectedMcpServers: target.selectedMcpServers ?? selectedMcpServers,
+            });
+        }
         if (target.requiresProjectOverview) {
             if (!overview?.trim()) {
                 throw new Error('Project overview is required to create AGENTS.md.');
             }
             contents = contents.replace('{{PROJECT_OVERVIEW}}', overview.trim());
         }
-        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
+        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
         return {
             label: target.label,
             targetPath: target.targetPath,
@@ -87,7 +158,7 @@ export function renderMissingWorkflowFiles({ missingTargets, overview, selectedL
         };
     });
 }
-export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], targets, }) {
+export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers, targets, }) {
     const previousState = readExistingState(statePath);
     const now = new Date().toISOString();
     const manifest = readTemplateManifest();
@@ -101,6 +172,8 @@ export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLa
         selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
         selectedArchitectureSkill: selectedArchitectureSkill?.id,
         selectedWorkflowSkills: selectedWorkflowSkills.map((skill) => skill.id),
+        selectedDatabaseSkills: selectedDatabaseSkills.map((skill) => skill.id),
+        ...(selectedMcpServers !== undefined ? { selectedMcpServers: selectedMcpServers.map((server) => server.id) } : {}),
         managedFiles: Object.fromEntries(targets
             .filter((target) => fs.existsSync(target.targetPath))
             .map((target) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juancr11/sibu",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "CLI for setting up a local AI-augmented development workflow.",
   "repository": {
     "type": "git",

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "templateVersion": "69",
+  "templateVersion": "74",
   "templates": {
     "AGENTS.md": {
       "version": "25",
@@ -9,10 +9,10 @@
       ]
     },
     ".codex/config.toml": {
-      "version": "1",
-      "description": "Codex configuration pointing to AGENTS.md.",
+      "version": "2",
+      "description": "Codex configuration pointing to AGENTS.md and rendering selected MCP servers with Codex-compatible settings.",
       "changes": [
-        "Configures Codex to use the root AGENTS.md instructions file."
+        "Updates Codex GitHub MCP rendering to use the hosted HTTPS endpoint with bearer_token_env_var instead of Docker command arguments."
       ]
     },
     "GEMINI.md": {
@@ -29,6 +29,20 @@
         "Delegates Claude project instructions to AGENTS.md as the source of truth."
       ]
     },
+    "mcp/claude/.mcp.json": {
+      "version": "2",
+      "description": "Claude MCP configuration template managed when selectable MCP servers are selected.",
+      "changes": [
+        "Updates Claude GitHub MCP rendering to use the hosted HTTPS endpoint with an Authorization header instead of Docker."
+      ]
+    },
+    "mcp/gemini/settings.json": {
+      "version": "2",
+      "description": "Gemini MCP configuration template managed when selectable MCP servers are selected.",
+      "changes": [
+        "Updates Gemini GitHub MCP rendering to use the hosted streamable HTTP endpoint with an Authorization header instead of Docker."
+      ]
+    },
     "skills/clean-code/SKILL.md": {
       "version": "4",
       "description": "Mandatory clean-code skill installed once at the shared .agents/skills workspace path.",
@@ -80,6 +94,13 @@
         "Adds an optional Go skill with concise, Effective Go\u2013style guidance for .go files, package APIs, interfaces, errors, receivers, concurrency, and tests."
       ]
     },
+    "skills/postgresql-expert/SKILL.md": {
+      "version": "1",
+      "description": "Selectable PostgreSQL Expert skill for practical database schema design and PostgreSQL-specific tradeoff guidance.",
+      "changes": [
+        "Adds an optional PostgreSQL Expert database skill focused on simple schema design, data integrity, migrations, access patterns, and purposeful indexing."
+      ]
+    },
     "skills/architecture/ddd-hexagonal/SKILL.md": {
       "version": "4",
       "description": "Selectable back-end architecture skill for DDD and Hexagonal Architecture.",
@@ -109,10 +130,10 @@
       ]
     },
     "skills/scrum-master-planner/SKILL.md": {
-      "version": "7",
+      "version": "8",
       "description": "Mandatory Scrum planner skill for creating pragmatic Epics and User Stories from approved feature and technical design docs.",
       "changes": [
-        "Updates Scrum planning guidance to preserve Deep Module implementation boundaries from technical designs."
+        "Adds optional GitHub issue export guidance after Scrum planning when GitHub MCP tools are available."
       ]
     },
     "skills/ai-implementation-planner/SKILL.md": {

package/templates/mcp/claude/.mcp.json

@@ -0,0 +1,3 @@
+{
+  "mcpServers": {}
+}

package/templates/mcp/gemini/settings.json

@@ -0,0 +1,3 @@
+{
+  "mcpServers": {}
+}

package/templates/skills/postgresql-expert/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: postgresql-expert
+description: Use this skill for PostgreSQL schema design, migrations, constraints, queries, indexing, and database tradeoffs when practical database judgment is needed.
+---
+
+# PostgreSQL Expert
+
+Use this skill when working with PostgreSQL database design or database-facing application changes.
+
+Apply this skill together with `clean-code`. Keep the guidance practical: prefer the simplest database design that protects data integrity and supports the application's real access patterns.
+
+## Use this skill for
+
+- designing or reviewing PostgreSQL schemas
+- planning migrations and safe schema evolution
+- choosing keys, constraints, relationships, and transactions
+- reasoning about queries, access patterns, and indexes
+- deciding whether PostgreSQL-specific features are worth using
+- reviewing database-related tradeoffs in application code
+
+## Core principles
+
+### 1. Start with the product model
+- Model the real domain concepts, not speculative future reporting or scaling needs.
+- Prefer clear table and column names that match product language.
+- Keep schemas boring until the product needs something more specialized.
+- Do not add tables, abstractions, or generic metadata columns just in case.
+
+### 2. Protect data integrity in the database
+- Use primary keys, foreign keys, `NOT NULL`, `UNIQUE`, and `CHECK` constraints when they express real invariants.
+- Prefer database-enforced integrity over relying only on application checks for durable rules.
+- Make deletion behavior explicit with appropriate foreign-key actions.
+- Use transactions when a change must succeed or fail as one unit.
+
+### 3. Evolve schemas safely
+- Treat migrations as production changes that need clear rollback or recovery thinking.
+- Prefer small, reversible migration steps for risky changes.
+- Avoid destructive changes until data has been backfilled, verified, and callers have moved over.
+- Consider lock behavior and table size before changing large production tables.
+
+### 4. Design from access patterns, not guesses
+- Understand the queries the application actually needs before optimizing.
+- Keep common reads and writes straightforward before introducing denormalization.
+- Use normalization for clarity and integrity; denormalize only for a measured or well-understood reason.
+- Explain tradeoffs when choosing between simpler schema shape and query convenience.
+
+### 5. Add indexes only when justified
+- Do not add indexes just because a column is used, foreign-keyed, or might be queried someday.
+- Add an index when there is a clear query, filtering, joining, sorting, uniqueness, or constraint need.
+- Remember that indexes speed some reads but add write cost, storage cost, and maintenance overhead.
+- Prefer a small number of purposeful indexes over broad defensive indexing.
+
+### 6. Use PostgreSQL features with restraint
+- Consider PostgreSQL capabilities such as JSONB, arrays, partial indexes, generated columns, enums, extensions, and full-text search when they simplify a real requirement.
+- Do not use PostgreSQL-specific features to appear sophisticated when standard relational modeling is clearer.
+- Be explicit about portability tradeoffs when choosing PostgreSQL-specific behavior.
+- Prefer built-in PostgreSQL capabilities before adding extra infrastructure.
+
+### 7. Keep database advice actionable
+- Tie recommendations to the schema, query, migration, or invariant at hand.
+- Say what evidence would change the recommendation, such as query plans, row counts, write volume, or latency targets.
+- When context is missing, ask for the relevant schema, migration, query, or access pattern instead of guessing.
+- Avoid broad DBA checklists unless the task is explicitly about operations or performance investigation.
+
+## Decision rule
+
+When unsure, prefer:
+1. simple schema design that matches current product needs
+2. explicit database constraints for real invariants
+3. safe, incremental migrations
+4. query-aware design over speculative optimization
+5. purposeful indexes over blanket indexing

package/templates/skills/scrum-master-planner/SKILL.md

@@ -210,6 +210,28 @@ Before finishing, verify:
 - no Story adds scope that is absent from the feature brief or technical design
 - acceptance criteria are testable enough for a reviewer
 
+### 6. Optionally export planning artifacts to GitHub Issues
+
+After all local Epic and User Story files are written, check whether GitHub MCP tools are available for issue creation, label creation, and native sub-issue mutation.
+
+If any required GitHub MCP capability is unavailable, do not offer GitHub export. Finish with the normal local planning response.
+
+If the required GitHub MCP capabilities are available:
+
+1. Resolve the target repository from the current local repo's GitHub `origin` remote only. Do not ask for or use another repository.
+2. Ask one explicit opt-in question before any GitHub mutation: "GitHub MCP is available. Create GitHub Issues for these Epics and User Stories in the current repo?"
+3. If the user declines, perform no GitHub mutation.
+4. If the user accepts, create a fresh issue set every time. Do not search for duplicates or update existing issues.
+5. Create missing labels before creating issues: `epic`, `user-story`, and `sibu-generated`.
+6. Create one issue per Epic with labels `epic` and `sibu-generated`.
+7. Create one issue per User Story with labels `user-story` and `sibu-generated`.
+8. Attach each User Story issue as a native GitHub sub-issue of its parent Epic issue.
+9. Report created issue numbers or URLs.
+
+Keep issue bodies concise and source-grounded. Include the source local doc path and relevant summary, scope, acceptance criteria, or validation notes. Do not modify local Markdown files with GitHub URLs.
+
+Native sub-issues are required for this export. Preserve each created User Story issue's GitHub issue `id` because native sub-issue APIs need the child issue ID, not only its issue number. If label creation, issue creation, issue ID access, or native sub-issue attachment fails or is unavailable, fail clearly and do not fall back to Markdown checklists, loose links, GitHub Projects, milestones, assignees, or status tracking.
+
 ## Final response behavior
 
 After writing files, final-answer with only: