@contextium/cli 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextium/cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Command-line tool for managing Contextium documentation, agents, skills, and workflows — pipe context to AI coding assistants",
   "keywords": [
     "contextium",

package/skills/ium/marketplace.md

@@ -3,71 +3,100 @@ name: ium:marketplace
 description: Browse, install, or publish skills, agents, and MCP servers on the Contextium Marketplace
 allowed-tools:
   - Bash
+  - mcp__contextium__search_marketplace
+  - mcp__contextium__get_marketplace_listing
+  - mcp__contextium__install_marketplace_listing
+  - mcp__contextium__list_agents
+  - mcp__contextium__list_skills
   - AskUserQuestion
 ---
 
 <objective>
-Interact with the Contextium Marketplace — browse what's available, install tools into your workspace, or publish your own skills, agents, and MCP servers.
+Help the user find and install the right tools from the Contextium Marketplace using natural language. Do not dump category lists — understand what they're trying to do and surface the best 5 matches across all types (skills, agents, MCP servers).
 </objective>
 
 <process>
 
 <step name="choose_action">
-Ask the user what they want to do using AskUserQuestion:
-- Question: "What would you like to do on the Marketplace?"
+Ask: "What would you like to do on the Marketplace?"
 - Options:
-  - "Browse & install — find skills, agents, or MCP servers to add to my workspace"
-  - "Publish — share a skill, agent, or MCP server with the community"
-  - "My installs — see what's installed in my workspace"
+  - "Find & install — I'll describe what I need"
+  - "Publish — share a skill, agent, or MCP server"
+  - "My installs — see what's in my workspace"
 </step>
 
-<step name="browse_and_install">
-If Browse & install selected:
+<step name="find_and_install">
+If Find & install selected:
 
-Ask: "What type of tool are you looking for?"
-- Options: "Skill", "Agent", "MCP Server", "Any"
+Ask: "What are you looking for? Describe what you want to do or what problem you want to solve."
 
-Ask: "Any keywords to search for? (or press enter to browse all)"
+Wait for a natural language response. Examples: "I want to plan and research my project", "I need something to help with writing", "I want to analyse customer feedback".
 
-Run the search:
-```bash
-contextium marketplace list -t <skill|agent|mcp_server> -q "<query>"
-```
+From their description, infer intent and search intelligently:
+
+1. Silently fetch what the user already has in their workspace:
+   - **CLI:** `contextium skills list -w <workspace> 2>/dev/null` and `contextium agents list -w <workspace> 2>/dev/null`
+   - **MCP:** call list_skills and list_agents
+
+2. Search the marketplace across all types using the user's keywords:
+   - **CLI:** `contextium marketplace list -q "<extracted keywords>" 2>/dev/null`
+   - **MCP:** call mcp__contextium__search_marketplace with the extracted keywords
+
+3. Decide which type(s) to prioritise based on what the user described:
+   - If they want to extend Claude's capabilities (web access, file parsing, external APIs) → prioritise MCP servers
+   - If they want a specialist assistant persona → prioritise agents
+   - If they want reusable knowledge or instructions → prioritise skills
+   - If something relevant already exists in their workspace → flag it as "you already have this" and skip suggesting it
 
-Omit `-t` if "Any" was selected. Omit `-q` if no keywords given.
+4. From all results, pick the top 5 that best match the intent. If fewer than 5 good matches exist, only show what's relevant — do not pad with irrelevant results.
+
+Present results like this:
 
-To see full details of a specific listing:
-```bash
-contextium marketplace show <slug>
 ```
+Here are the best matches for what you described:
+
+1. **Name** (type: skill / agent / mcp)
+   What it does and why it fits what you described.
+
+2. **Name** (type: ...)
+   ...
 
-Once the user picks a listing, install it:
-```bash
-contextium marketplace install <slug> -w <workspace>
+↗ Already in your workspace: "Name" — this already covers part of what you need.
 ```
 
-Confirm installed and tell the user where to find it (Skills page, Agents page, etc.).
+Ask: "Which would you like to install? Give me a number, or say skip."
+
+If the user picks one, fetch full details and install:
+- **CLI:** `contextium marketplace show <slug>` then `contextium marketplace install <slug> -w <workspace>`
+- **MCP:** call get_marketplace_listing then install_marketplace_listing
+
+Confirm: `✓ Installed "<Name>" into your workspace.`
+
+Ask if they want to install another from the list or search for something different.
 </step>
 
 <step name="publish">
 If Publish selected:
 
-The CLI does not support publishing — direct the user to the web marketplace.
-
 "Publishing is done via the web UI. Go to https://contextium.io/marketplace and click 'Publish' to share your skill, agent, or MCP server."
 </step>
 
 <step name="my_installs">
 If My installs selected:
 
-The CLI does not have a list-installed command. List the workspace's skills and agents instead:
+Silently fetch the workspace's skills and agents:
+- **CLI:** `contextium skills list -w <workspace> 2>/dev/null` and `contextium agents list -w <workspace> 2>/dev/null`
+- **MCP:** call list_skills and list_agents
 
-```bash
-contextium skills list -w <workspace>
-contextium agents list -w <workspace>
-```
-
-Show what's available and offer to install more from the marketplace.
+Show a clean list grouped by type. Offer to search for more.
 </step>
 
 </process>
+
+<rules>
+- Never ask the user to pick a type (skill / agent / MCP) — infer it from what they describe
+- Never show all marketplace items — always filter to top 5 relevant results
+- Always check what the user already has before suggesting installs
+- Do not show raw CLI output, IDs, or slugs to the user
+- If search returns nothing useful, say so and ask them to rephrase
+</rules>

package/skills/ium/new-project.md

@@ -1,22 +1,26 @@
 ---
 name: ium:new-project
-description: Set up a new Contextium project — authenticate, pick a workspace, create libraries, agents, skills, and a workflow
+description: Set up a new Contextium project — authenticate, pick a workspace, describe project, intelligently suggest and create libraries, agents, skills, tags, and a workflow
 allowed-tools:
   - Bash
   - mcp__contextium__list_workspaces
   - mcp__contextium__create_context_library
-  - mcp__contextium__create_agent
-  - mcp__contextium__create_skill
-  - mcp__contextium__create_workflow
   - mcp__contextium__list_context_libraries
+  - mcp__contextium__create_agent
   - mcp__contextium__list_agents
+  - mcp__contextium__create_skill
   - mcp__contextium__list_skills
+  - mcp__contextium__create_workflow
   - mcp__contextium__list_workflows
+  - mcp__contextium__list_tags
+  - mcp__contextium__list_tag_types
+  - mcp__contextium__create_tag
+  - mcp__contextium__create_tag_type
   - AskUserQuestion
 ---
 
 <objective>
-Set up a new Contextium project — workspace selection, context libraries, agents, skills, and a workflow.
+Set up a new Contextium project intelligently — understand what the user is trying to do, quietly analyse the workspace for existing resources, then recommend exactly what to create (libraries, agents, skills, tags, workflow) with clear reasoning. Get confirmation before creating anything.
 </objective>
 
 <mode-detection>
@@ -28,7 +32,7 @@ command -v contextium &>/dev/null && echo "cli" || echo "no-cli"
 
 - If `cli`: use CLI commands throughout. Do not attempt MCP tools.
 - If `no-cli`: check if mcp__contextium__list_workspaces is available. If yes, use MCP tools throughout.
-- If neither: tell the user "Contextium doesn't appear to be installed. Install the CLI with `npm install -g @contextium/cli` or connect the MCP server, then re-run this."
+- If neither: tell the user "Contextium doesn't appear to be installed. Install the CLI with `npm install -g @contextium/cli` or connect the MCP server, then re-run this." Stop here.
 
 Do not mention the mode to the user. Pick one path and stick with it.
 </mode-detection>
@@ -54,56 +58,143 @@ Ask: "Which workspace is this project for?"
 Present names only — no IDs, no raw output.
 </step>
 
-<step name="project_structure">
-Ask: "What context libraries do you need? (e.g. Product Docs, Internal Guides, Meeting Notes)"
+<step name="project_description">
+Ask the user this question exactly:
 
-**CLI:** `contextium library create "<name>" --workspace <slug>` for each.
-**MCP:** mcp__contextium__create_context_library for each.
+"Tell me about your project — what are you trying to do, what topics are involved, and what kind of work will you be doing with this? The more detail you give me, the better I can set things up for you."
 
-Show `✓ Created "Library Name"` per library.
+Wait for their response. Store it as the project description. Do not proceed until you have a meaningful answer.
 </step>
 
-<step name="agents">
-Ask: "Do you want to create any agents? Give them names and a one-line purpose, or say skip."
+<step name="quiet_analysis">
+Silently fetch all existing workspace resources. Do not show raw output or errors. Show only these progress lines as you go:
 
-**CLI:** `contextium agent create "<name>" --workspace <slug>` for each.
-**MCP:** mcp__contextium__create_agent for each.
+```
+Searching libraries...
+Searching agents...
+Searching skills...
+Searching tags...
+```
 
-Show `✓ Created agent "Name"` per agent.
-</step>
+**CLI:**
+```bash
+contextium library list --workspace <slug> 2>/dev/null
+contextium agent list --workspace <slug> 2>/dev/null
+contextium skill list --workspace <slug> 2>/dev/null
+contextium tag list --workspace <slug> 2>/dev/null
+```
 
-<step name="skills">
-Ask: "Any skills to add? Skills are reusable knowledge blocks (e.g. brand guidelines, refund policy). Name them or say skip."
+**MCP:** call list_context_libraries, list_agents, list_skills, list_tags — all for the selected workspace. Suppress any errors silently.
 
-**CLI:** `contextium skill create "<name>" --workspace <slug>` for each.
-**MCP:** mcp__contextium__create_skill for each.
+After all four searches complete, output this line:
+```
+Creating Contextium setup plan...
+```
+
+Then analyse the results against the project description:
+- Which existing libraries (if any) are relevant to what the user described?
+- Which existing agents (if any) could serve this project?
+- Which existing skills (if any) are applicable?
+- Which existing tags/tag types (if any) relate to the topics mentioned?
 
-Show `✓ Created skill "Name"` per skill.
+Internally categorise everything as: **reuse** (relevant, already exists) or **create** (needed, does not exist).
 </step>
 
-<step name="workflow">
-Ask: "What should the workflow be called? This bundles your libraries, agents, and skills for quick loading."
+<step name="intelligent_plan">
+Based on the project description and the analysis, build a setup plan. Think through:
+
+**Libraries:** What distinct knowledge areas did the user mention? Each major topic or type of content that needs to be stored separately should be its own library. If an existing library already covers one of these, mark it for reuse.
+
+**Agents:** What kind of AI assistant roles would serve this project? Think about what tasks the user will perform — research, writing, analysis, Q&A, etc. If an existing agent fits, mark it for reuse.
+
+**Skills:** What reusable knowledge blocks would help agents working on this project? Think about domain-specific guidelines, reference material, or persistent context the agent needs. If an existing skill fits, mark it for reuse.
+
+**Tags:** What topic or category labels would make sense for organising content in this project? Look for existing tag types that match. If none exist, suggest new ones. Think in terms of tag categories (e.g. `topic`, `source`, `status`) and the specific tag values within them (e.g. `topic:space-travel`, `topic:rocket-engineering`).
+
+**Workflow:** Propose one workflow name that bundles everything together for quick loading.
+
+Present the plan in this format (omit any section that has nothing in it):
+
+---
+
+Here's what I'll set up for you:
 
-**CLI:** `contextium workflow create "<name>" --workspace <slug>`.
-**MCP:** mcp__contextium__create_workflow.
+**New libraries to create**
+- "Library Name" — reason why this is needed
 
-Show `✓ Created workflow "Name"`.
+**Existing libraries to reuse**
+- "Library Name" — why it's relevant
+
+**New agents to create**
+- "Agent Name" — what it will do for this project
+
+**Existing agents to reuse**
+- "Agent Name" — why it fits
+
+**New skills to create**
+- "Skill Name" — what knowledge it will hold
+
+**Existing skills to reuse**
+- "Skill Name" — why it fits
+
+**Tags to create**
+- `category:value` — why this label is useful
+
+**Workflow**
+- "Workflow Name" — bundles everything above for quick loading
+
+Shall I go ahead and create all of this?
+
+---
+
+Wait for the user to confirm, adjust, or say skip on any item before proceeding.
 </step>
 
-<step name="summary">
-Show a clean summary:
+<step name="create_resources">
+Only create what the user confirmed. Create in this order: tag types → tags → libraries → skills → agents → workflow.
+
+Show `✓ Created "Name"` for each item as it is created. Show `↗ Reusing "Name"` for each existing resource being included.
 
+Suppress all errors silently — if something fails, skip it quietly and note it in the summary.
+
+**CLI commands:**
+```bash
+contextium library create "<name>" --workspace <slug>
+contextium agent create "<name>" --workspace <slug>
+contextium skill create "<name>" --workspace <slug>
+contextium workflow create "<name>" --workspace <slug>
+contextium tag create "<value>" --type <type-slug> --workspace <slug>
+contextium tag-type create "<name>" --workspace <slug>
 ```
-✓ Contextium project ready
 
-Workspace:  <name>
-Libraries:  <list>
-Agents:     <list or none>
-Skills:     <list or none>
-Workflow:   <name>
+**MCP:** use the corresponding create_* tools for each resource type.
+</step>
+
+<step name="load_workflow">
+After all resources are created, automatically load the workflow without asking the user. Run silently:
+
+**CLI:** `contextium workflow load "<workflow-name>" --workspace <slug> 2>/dev/null`
+**MCP:** call mcp__contextium__load_workflow with the workflow name and workspace.
+
+Do not tell the user to load it themselves — just load it as part of setup.
+</step>
+
+<step name="summary">
+Show a clean final summary:
 
-Load it anytime with /ium:workflow.
 ```
+✓ Project ready
+
+Workspace:   <name>
+Libraries:   <list — new + reused>
+Agents:      <list — new + reused, or none>
+Skills:      <list — new + reused, or none>
+Tags:        <list, or none>
+Workflow:    <name> — loaded and ready
+```
+
+If anything failed to create, add a single line at the end:
+`⚠ Could not create: <list of names> — you can add these manually.`
 </step>
 
 </process>
@@ -111,7 +202,10 @@ Load it anytime with /ium:workflow.
 <rules>
 - Never say "the wizard", "Contextium would like to know", or "the next step is"
 - Never show raw bash output, API responses, or IDs to the user
-- Run all checks silently — only surface errors or the final summary
-- Ask questions directly, one step at a time
-- If a CLI command fails, show the error message only — not the full command
+- Run all checks and fetches silently — only surface progress labels and the final plan
+- Only ask questions when genuinely needed — the description step and the confirmation step
+- Do not ask the user what to create — figure it out from the description, then ask them to confirm
+- If a resource already exists and is relevant, always prefer reuse over creating a duplicate
+- The plan report must explain the reasoning for each item — not just list names
+- Never create anything before the user confirms the plan
 </rules>