@hanzlaa/rcode 2.1.0

package/rihal/skills/core/rihal-init/scripts/tests/test_rihal_init.py

@@ -0,0 +1,329 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml"]
+# ///
+
+#!/usr/bin/env python3
+"""Unit tests for rihal_init.py"""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from rihal_init import (
+    find_project_root,
+    parse_var_specs,
+    resolve_project_root_placeholder,
+    expand_template,
+    apply_result_template,
+    load_module_yaml,
+    find_core_module_yaml,
+    find_target_module_yaml,
+    load_config_file,
+    load_module_config,
+)
+
+
+class TestFindProjectRoot(unittest.TestCase):
+
+    def test_finds_rihal_folder(self):
+        temp_dir = tempfile.mkdtemp()
+        try:
+            (Path(temp_dir) / '_rihal').mkdir()
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                result = find_project_root()
+                self.assertEqual(result.resolve(), Path(temp_dir).resolve())
+            finally:
+                os.chdir(original_cwd)
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_llm_provided_with_rihal(self):
+        temp_dir = tempfile.mkdtemp()
+        try:
+            (Path(temp_dir) / '_rihal').mkdir()
+            result = find_project_root(llm_provided=temp_dir)
+            self.assertEqual(result.resolve(), Path(temp_dir).resolve())
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_llm_provided_without_rihal_still_returns_dir(self):
+        """First-run case: LLM provides path but _rihal doesn't exist yet."""
+        temp_dir = tempfile.mkdtemp()
+        try:
+            result = find_project_root(llm_provided=temp_dir)
+            self.assertEqual(result.resolve(), Path(temp_dir).resolve())
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestParseVarSpecs(unittest.TestCase):
+
+    def test_vars_with_defaults(self):
+        specs = parse_var_specs('var1:value1,var2:value2')
+        self.assertEqual(len(specs), 2)
+        self.assertEqual(specs[0]['name'], 'var1')
+        self.assertEqual(specs[0]['default'], 'value1')
+
+    def test_vars_without_defaults(self):
+        specs = parse_var_specs('var1,var2')
+        self.assertEqual(len(specs), 2)
+        self.assertIsNone(specs[0]['default'])
+
+    def test_mixed_vars(self):
+        specs = parse_var_specs('required_var,var2:default2')
+        self.assertIsNone(specs[0]['default'])
+        self.assertEqual(specs[1]['default'], 'default2')
+
+    def test_colon_in_default(self):
+        specs = parse_var_specs('path:{project-root}/some/path')
+        self.assertEqual(specs[0]['default'], '{project-root}/some/path')
+
+    def test_empty_string(self):
+        self.assertEqual(parse_var_specs(''), [])
+
+    def test_none(self):
+        self.assertEqual(parse_var_specs(None), [])
+
+
+class TestResolveProjectRootPlaceholder(unittest.TestCase):
+
+    def test_resolve_placeholder(self):
+        result = resolve_project_root_placeholder('{project-root}/output', Path('/test'))
+        self.assertEqual(result, '/test/output')
+
+    def test_no_placeholder(self):
+        result = resolve_project_root_placeholder('/absolute/path', Path('/test'))
+        self.assertEqual(result, '/absolute/path')
+
+    def test_none(self):
+        self.assertIsNone(resolve_project_root_placeholder(None, Path('/test')))
+
+    def test_non_string(self):
+        self.assertEqual(resolve_project_root_placeholder(42, Path('/test')), 42)
+
+
+class TestExpandTemplate(unittest.TestCase):
+
+    def test_basic_expansion(self):
+        result = expand_template('{project-root}/output', {'project-root': '/test'})
+        self.assertEqual(result, '/test/output')
+
+    def test_multiple_placeholders(self):
+        result = expand_template(
+            '{output_folder}/planning',
+            {'output_folder': '_rihal-output', 'project-root': '/test'}
+        )
+        self.assertEqual(result, '_rihal-output/planning')
+
+    def test_none_value(self):
+        self.assertIsNone(expand_template(None, {}))
+
+    def test_non_string(self):
+        self.assertEqual(expand_template(42, {}), 42)
+
+
+class TestApplyResultTemplate(unittest.TestCase):
+
+    def test_with_result_template(self):
+        var_def = {'result': '{project-root}/{value}'}
+        result = apply_result_template(var_def, '_rihal-output', {'project-root': '/test'})
+        self.assertEqual(result, '/test/_rihal-output')
+
+    def test_without_result_template(self):
+        result = apply_result_template({}, 'raw_value', {})
+        self.assertEqual(result, 'raw_value')
+
+    def test_value_only_template(self):
+        var_def = {'result': '{value}'}
+        result = apply_result_template(var_def, 'English', {})
+        self.assertEqual(result, 'English')
+
+
+class TestLoadModuleYaml(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_loads_core_module_yaml(self):
+        path = Path(self.temp_dir) / 'module.yaml'
+        path.write_text(
+            'code: core\n'
+            'name: "Rihal Core Module"\n'
+            'header: "Core Config"\n'
+            'user_name:\n'
+            '  prompt: "What should agents call you?"\n'
+            '  default: "Rihal"\n'
+            '  result: "{value}"\n'
+        )
+        result = load_module_yaml(path)
+        self.assertIsNotNone(result)
+        self.assertEqual(result['meta']['code'], 'core')
+        self.assertEqual(result['meta']['name'], 'Rihal Core Module')
+        self.assertIn('user_name', result['variables'])
+        self.assertEqual(result['variables']['user_name']['prompt'], 'What should agents call you?')
+
+    def test_loads_module_with_directories(self):
+        path = Path(self.temp_dir) / 'module.yaml'
+        path.write_text(
+            'code: bmm\n'
+            'name: "Rihal Method"\n'
+            'project_name:\n'
+            '  prompt: "Project name?"\n'
+            '  default: "{directory_name}"\n'
+            '  result: "{value}"\n'
+            'directories:\n'
+            '  - "{planning_artifacts}"\n'
+        )
+        result = load_module_yaml(path)
+        self.assertEqual(result['directories'], ['{planning_artifacts}'])
+
+    def test_returns_none_for_missing(self):
+        result = load_module_yaml(Path(self.temp_dir) / 'nonexistent.yaml')
+        self.assertIsNone(result)
+
+    def test_returns_none_for_empty(self):
+        path = Path(self.temp_dir) / 'empty.yaml'
+        path.write_text('')
+        result = load_module_yaml(path)
+        self.assertIsNone(result)
+
+
+class TestFindCoreModuleYaml(unittest.TestCase):
+
+    def test_returns_path_to_resources(self):
+        path = find_core_module_yaml()
+        self.assertTrue(str(path).endswith('resources/core-module.yaml'))
+
+
+class TestFindTargetModuleYaml(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.project_root = Path(self.temp_dir)
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_finds_in_skill_assets(self):
+        skill_path = self.project_root / 'skills' / 'test-skill'
+        assets = skill_path / 'assets'
+        assets.mkdir(parents=True)
+        (assets / 'module.yaml').write_text('code: test\n')
+
+        result = find_target_module_yaml('test', self.project_root, str(skill_path))
+        self.assertIsNotNone(result)
+        self.assertTrue(str(result).endswith('assets/module.yaml'))
+
+    def test_finds_in_skill_root(self):
+        skill_path = self.project_root / 'skills' / 'test-skill'
+        skill_path.mkdir(parents=True)
+        (skill_path / 'module.yaml').write_text('code: test\n')
+
+        result = find_target_module_yaml('test', self.project_root, str(skill_path))
+        self.assertIsNotNone(result)
+
+    def test_finds_in_rihal_module_dir(self):
+        module_dir = self.project_root / '_rihal' / 'mymod'
+        module_dir.mkdir(parents=True)
+        (module_dir / 'module.yaml').write_text('code: mymod\n')
+
+        result = find_target_module_yaml('mymod', self.project_root)
+        self.assertIsNotNone(result)
+
+    def test_returns_none_when_not_found(self):
+        result = find_target_module_yaml('missing', self.project_root)
+        self.assertIsNone(result)
+
+    def test_skill_path_takes_priority(self):
+        """Skill assets module.yaml takes priority over _rihal/{module}/."""
+        skill_path = self.project_root / 'skills' / 'test-skill'
+        assets = skill_path / 'assets'
+        assets.mkdir(parents=True)
+        (assets / 'module.yaml').write_text('code: test\nname: from-skill\n')
+
+        module_dir = self.project_root / '_rihal' / 'test'
+        module_dir.mkdir(parents=True)
+        (module_dir / 'module.yaml').write_text('code: test\nname: from-rihal\n')
+
+        result = find_target_module_yaml('test', self.project_root, str(skill_path))
+        self.assertTrue('assets' in str(result))
+
+
+class TestLoadConfigFile(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_loads_flat_yaml(self):
+        path = Path(self.temp_dir) / 'config.yaml'
+        path.write_text('user_name: Test\ncommunication_language: English\n')
+        result = load_config_file(path)
+        self.assertEqual(result['user_name'], 'Test')
+
+    def test_returns_none_for_missing(self):
+        result = load_config_file(Path(self.temp_dir) / 'missing.yaml')
+        self.assertIsNone(result)
+
+
+class TestLoadModuleConfig(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.project_root = Path(self.temp_dir)
+        rihal_core = self.project_root / '_rihal' / 'core'
+        rihal_core.mkdir(parents=True)
+        (rihal_core / 'config.yaml').write_text(
+            'user_name: TestUser\n'
+            'communication_language: English\n'
+            'document_output_language: English\n'
+            'output_folder: "{project-root}/_rihal-output"\n'
+        )
+        rihal_bmb = self.project_root / '_rihal' / 'bmb'
+        rihal_bmb.mkdir(parents=True)
+        (rihal_bmb / 'config.yaml').write_text(
+            'user_name: TestUser\n'
+            'communication_language: English\n'
+            'document_output_language: English\n'
+            'output_folder: "{project-root}/_rihal-output"\n'
+            'rihal_builder_output_folder: "{project-root}/_rihal-output/skills"\n'
+            'rihal_builder_reports: "{project-root}/_rihal-output/reports"\n'
+        )
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def test_load_core(self):
+        result = load_module_config('core', self.project_root)
+        self.assertIsNotNone(result)
+        self.assertEqual(result['user_name'], 'TestUser')
+
+    def test_load_module_includes_core_vars(self):
+        result = load_module_config('bmb', self.project_root)
+        self.assertIsNotNone(result)
+        # Module-specific var
+        self.assertIn('rihal_builder_output_folder', result)
+        # Core vars also present
+        self.assertEqual(result['user_name'], 'TestUser')
+
+    def test_missing_module(self):
+        result = load_module_config('nonexistent', self.project_root)
+        self.assertIsNone(result)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/rihal/skills/core/rihal-party-mode/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: rihal-party-mode
+description: >
+  Orchestrates group discussions between all installed Rihal agents, enabling
+  natural multi-agent conversations with maintained personalities. Activates
+  when the user says "party mode", "activate party mode", "start party mode",
+  "group discussion", "team discussion", "talk to everyone", "bring all agents",
+  "multi-agent chat", or "let's have a party". Do NOT use for: formal council
+  decisions (use rihal-majlis-council), single-agent questions where one
+  specialist is clearly the right owner (invoke that agent directly), or
+  sprint ceremonies (use rihal-hussain-sm).
+user-invocable: true
+---
+
+# Party Mode
+
+Brings together the full Rihal agent team for natural multi-agent conversations. Each agent maintains their unique personality and expertise while a facilitator manages flow, relevance-based agent selection, and cross-talk.
+
+## Workflow
+
+Follow the instructions in ./workflow.md.
+
+## Output Format
+
+Interactive conversation where each agent speaks in character with their emoji prefix. The facilitator selects 3-5 relevant agents per round based on the topic. Conversation continues until the user exits party mode.
+
+```
+🎯 Sadiq: [strategic perspective]
+🏗️ Waleed: [technical perspective]
+📋 Ahmed: [delivery perspective]
+...
+```
+
+## Examples
+
+### Happy path
+**User:** "party mode — should we build a mobile app?"
+**Result:** Facilitator loads team.yaml → selects Sadiq, Waleed, Hussain, Mariam → each speaks in character → user steers discussion
+
+### Edge case
+**User:** "party mode" (no topic)
+**Result:** Facilitator asks what topic to discuss, then selects relevant agents
+
+### Negative boundary
+**User:** "convene the majlis for a formal decision"
+**Result:** Not party mode → route to `rihal-majlis-council` for structured consensus with voting
+
+## Output Format
+
+Each party mode turn follows this pattern:
+
+```
+🎉 PARTY MODE — {topic}
+
+**{Agent Emoji} {Agent Name} ({Role}):**
+{Agent's response in their documented communication style}
+
+**{Agent Emoji} {Agent Name} ({Role}):**
+{Response, may reference previous agent's point}
+
+---
+💬 What would you like to discuss next? (say "exit" to end party mode)
+```
+
+## Examples
+
+### Happy path
+**User:** "party mode — should we build a mobile app?"
+**Result:** Facilitator activates party mode, selects Sadiq (strategy), Waleed (CTO), Hussain (PM), and Mariam (marketing). Each gives perspective in-character. User can steer the conversation, address specific agents, or ask follow-ups.
+
+### Edge case
+**User:** "party mode" (no topic)
+**Result:** Facilitator introduces the agent roster and asks "What would you like to discuss with the team today?"
+
+### Negative boundary
+**User:** "party mode — approve this PR"
+**Result:** Redirects to `/rihal:code-review` — code review needs structured evaluation, not open discussion.

package/rihal/skills/core/rihal-party-mode/steps/step-01-agent-loading.md

@@ -0,0 +1,138 @@
+# Step 1: Agent Loading and Party Mode Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- ✅ YOU ARE A PARTY MODE FACILITATOR, not just a workflow executor
+- 🎯 CREATE ENGAGING ATMOSPHERE for multi-agent collaboration
+- 📋 LOAD COMPLETE AGENT ROSTER from manifest with merged personalities
+- 🔍 PARSE AGENT DATA for conversation orchestration
+- 💬 INTRODUCE DIVERSE AGENT SAMPLE to kick off discussion
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show agent loading process before presenting party activation
+- ⚠️ Present [C] continue option after agent roster is loaded
+- 💾 ONLY save when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1]` before loading next step
+- 🚫 FORBIDDEN to start conversation until C is selected
+
+## CONTEXT BOUNDARIES:
+
+- Agent manifest CSV is available at `{project-root}/.rihal/team.yaml`
+- User configuration from config.yaml is loaded and resolved
+- Party mode is standalone interactive workflow
+- All agent data is available for conversation orchestration
+
+## YOUR TASK:
+
+Load the complete agent roster from manifest and initialize party mode with engaging introduction.
+
+## AGENT LOADING SEQUENCE:
+
+### 1. Load Agent Manifest
+
+Begin agent loading process:
+
+"Now initializing **Party Mode** with our complete Rihal agent roster! Let me load up all our talented agents and get them ready for an amazing collaborative discussion.
+
+**Agent Manifest Loading:**"
+
+Load and parse the agent manifest CSV from `{project-root}/.rihal/team.yaml`
+
+### 2. Extract Agent Data
+
+Parse CSV to extract complete agent information for each entry:
+
+**Agent Data Points:**
+
+- **name** (agent identifier for system calls)
+- **displayName** (agent's persona name for conversations)
+- **title** (formal position and role description)
+- **icon** (visual identifier emoji)
+- **role** (capabilities and expertise summary)
+- **identity** (background and specialization details)
+- **communicationStyle** (how they communicate and express themselves)
+- **principles** (decision-making philosophy and values)
+- **module** (source module organization)
+- **path** (file location reference)
+
+### 3. Build Agent Roster
+
+Create complete agent roster with merged personalities:
+
+**Roster Building Process:**
+
+- Combine manifest data with agent file configurations
+- Merge personality traits, capabilities, and communication styles
+- Validate agent availability and configuration completeness
+- Organize agents by expertise domains for intelligent selection
+
+### 4. Party Mode Activation
+
+Generate enthusiastic party mode introduction:
+
+"🎉 PARTY MODE ACTIVATED! 🎉
+
+Welcome {{user_name}}! I'm excited to facilitate an incredible multi-agent discussion with our complete Rihal team. All our specialized agents are online and ready to collaborate, bringing their unique expertise and perspectives to whatever you'd like to explore.
+
+**Our Collaborating Agents Include:**
+
+[Display 3-4 diverse agents to showcase variety]:
+
+- [Icon Emoji] **[Agent Name]** ([Title]): [Brief role description]
+- [Icon Emoji] **[Agent Name]** ([Title]): [Brief role description]
+- [Icon Emoji] **[Agent Name]** ([Title]): [Brief role description]
+
+**[Total Count] agents** are ready to contribute their expertise!
+
+**What would you like to discuss with the team today?**"
+
+### 5. Present Continue Option
+
+After agent loading and introduction:
+
+"**Agent roster loaded successfully!** All our Rihal experts are excited to collaborate with you.
+
+**Ready to start the discussion?**
+[C] Continue - Begin multi-agent conversation
+
+### 6. Handle Continue Selection
+
+#### If 'C' (Continue):
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Set `agents_loaded: true` and `party_active: true`
+- Load: `./step-02-discussion-orchestration.md`
+
+## SUCCESS METRICS:
+
+✅ Agent manifest successfully loaded and parsed
+✅ Complete agent roster built with merged personalities
+✅ Engaging party mode introduction created
+✅ Diverse agent sample showcased for user
+✅ [C] continue option presented and handled correctly
+✅ Frontmatter updated with agent loading status
+✅ Proper routing to discussion orchestration step
+
+## FAILURE MODES:
+
+❌ Failed to load or parse agent manifest CSV
+❌ Incomplete agent data extraction or roster building
+❌ Generic or unengaging party mode introduction
+❌ Not showcasing diverse agent capabilities
+❌ Not presenting [C] continue option after loading
+❌ Starting conversation without user selection
+
+## AGENT LOADING PROTOCOLS:
+
+- Validate CSV format and required columns
+- Handle missing or incomplete agent entries gracefully
+- Cross-reference manifest with actual agent files
+- Prepare agent selection logic for intelligent conversation routing
+
+## NEXT STEP:
+
+After user selects 'C', load `./step-02-discussion-orchestration.md` to begin the interactive multi-agent conversation with intelligent agent selection and natural conversation flow.
+
+Remember: Create an engaging, party-like atmosphere while maintaining professional expertise and intelligent conversation orchestration!