@contextium/cli 0.6.7 → 0.7.1

package/dist/lib/wizard.js

@@ -0,0 +1,910 @@
+import * as p from '@clack/prompts';
+import fs from 'fs/promises';
+import path from 'path';
+import { ApiClient } from './api-client.js';
+import { loadConfig, saveConfig } from './config.js';
+import { getCachedAccount, loginInteractive, getAccessToken } from './msal.js';
+import { addClaudePermission, isClaudePermissionConfigured } from './claude-permissions.js';
+import { createInitialState } from './wizard-state.js';
+const DEFAULT_API_URL = 'https://api.contextium.io/api/v1';
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function cancel(msg = 'Setup cancelled. Run "contextium setup" again at any time.') {
+    p.cancel(msg);
+    process.exit(0);
+}
+function guard(value) {
+    if (p.isCancel(value))
+        cancel();
+    return value;
+}
+function scoreMatch(description, name, agentDesc = '') {
+    const words = description.toLowerCase().split(/\W+/).filter(w => w.length > 3);
+    const target = `${name} ${agentDesc}`.toLowerCase();
+    return words.filter(w => target.includes(w)).length;
+}
+function suggestLibraries(description) {
+    const d = description.toLowerCase();
+    const domains = [
+        {
+            keywords: ['market', 'campaign', 'brand', 'advertis', 'social', 'content', 'copy', 'creative'],
+            libraries: [
+                { name: 'Campaign Assets', purpose: 'campaign briefs, creative files, copy' },
+                { name: 'Brand Guidelines', purpose: 'tone of voice, logo usage, colour palette' },
+            ],
+        },
+        {
+            keywords: ['api', 'developer', 'technical', 'documentation', 'code', 'engineer', 'software'],
+            libraries: [
+                { name: 'API Documentation', purpose: 'endpoints, authentication, examples' },
+                { name: 'Technical Specs', purpose: 'architecture, requirements, decisions' },
+            ],
+        },
+        {
+            keywords: ['product', 'feature', 'roadmap', 'launch', 'user research', 'pricing', 'spec'],
+            libraries: [
+                { name: 'Product Documentation', purpose: 'features, requirements, roadmap' },
+                { name: 'User Research', purpose: 'interviews, insights, personas' },
+            ],
+        },
+        {
+            keywords: ['sales', 'customer', 'crm', 'deal', 'pipeline', 'prospect', 'pitch'],
+            libraries: [
+                { name: 'Sales Playbook', purpose: 'pitches, objection handling, scripts' },
+                { name: 'Customer Intelligence', purpose: 'personas, case studies, win/loss' },
+            ],
+        },
+        {
+            keywords: ['hr', 'hiring', 'recruit', 'onboard', 'employee', 'people', 'talent'],
+            libraries: [
+                { name: 'HR Documentation', purpose: 'policies, processes, job descriptions' },
+                { name: 'Onboarding Materials', purpose: 'guides, checklists, welcome docs' },
+            ],
+        },
+        {
+            keywords: ['legal', 'compliance', 'contract', 'policy', 'regulation', 'gdpr', 'terms'],
+            libraries: [
+                { name: 'Legal & Compliance', purpose: 'contracts, policies, regulatory docs' },
+            ],
+        },
+        {
+            keywords: ['finance', 'budget', 'forecast', 'report', 'account', 'revenue', 'cost'],
+            libraries: [
+                { name: 'Financial Documentation', purpose: 'budgets, forecasts, reports' },
+            ],
+        },
+        {
+            keywords: ['design', 'ux', 'ui', 'figma', 'prototype', 'wireframe', 'user experience'],
+            libraries: [
+                { name: 'Design System', purpose: 'components, patterns, guidelines' },
+                { name: 'UX Research', purpose: 'usability tests, user journeys, findings' },
+            ],
+        },
+    ];
+    const scored = domains.map(domain => ({
+        libraries: domain.libraries,
+        score: domain.keywords.filter(k => d.includes(k)).length,
+    })).filter(d => d.score > 0).sort((a, b) => b.score - a.score);
+    if (scored.length > 0) {
+        return scored[0].libraries;
+    }
+    // Generic fallback
+    return [{ name: 'Project Documentation', purpose: 'key documents, references, notes' }];
+}
+// ─── API client factory ───────────────────────────────────────────────────────
+function makeClient(state) {
+    return new ApiClient(state.apiKey || '', state.apiUrl);
+}
+// ─── Step 0 — Silent state detection ─────────────────────────────────────────
+async function detectState(force) {
+    const account = await getCachedAccount();
+    const token = account ? await getAccessToken() : null;
+    const existingConfig = await loadConfig().catch(() => null);
+    const apiKey = existingConfig?.api_key || process.env.CONTEXTIUM_API_KEY || '';
+    const isAuthed = !!(token || apiKey);
+    const hasConfig = await fs.access(path.join(process.cwd(), '.contextiumrc')).then(() => true).catch(() => false);
+    const hasWorkspace = !!(existingConfig?.workspace_id);
+    const isClaudeConfigured = await isClaudePermissionConfigured('global') || await isClaudePermissionConfigured('project');
+    if (!force && isAuthed && hasConfig && hasWorkspace && isClaudeConfigured) {
+        p.intro('Contextium — already configured');
+        p.note([
+            `Workspace:  ${existingConfig?.workspace || existingConfig?.workspace_id || 'set'}`,
+            `Config:     .contextiumrc`,
+            `Claude:     permissions configured`,
+            '',
+            'Run with --force to reconfigure.',
+        ].join('\n'), 'You\'re all set!');
+        p.outro('Run "contextium setup --force" to reconfigure everything.');
+        process.exit(0);
+    }
+    return { isAuthed, account, hasConfig, hasWorkspace, isClaudeConfigured, existingConfig };
+}
+// ─── Step 2 — Authentication ──────────────────────────────────────────────────
+async function stepAuth(state, detected) {
+    if (detected.isAuthed && !state.account) {
+        state.account = detected.account;
+        state.authMethod = 'existing';
+        if (detected.existingConfig?.api_key)
+            state.apiKey = detected.existingConfig.api_key;
+        if (detected.existingConfig?.api_url)
+            state.apiUrl = detected.existingConfig.api_url;
+        p.log.success(`Already authenticated${detected.account?.name ? ` as ${detected.account.name}` : ''}`);
+        return;
+    }
+    const method = guard(await p.select({
+        message: 'How would you like to authenticate?',
+        options: [
+            { value: 'entra', label: 'Browser login (Microsoft Entra ID)', hint: 'recommended' },
+            { value: 'apikey', label: 'API key' },
+        ],
+    }));
+    if (method === 'entra') {
+        state.authMethod = 'entra';
+        const s = p.spinner();
+        s.start('Opening browser for authentication...');
+        try {
+            const result = await loginInteractive();
+            state.account = result.account;
+            s.stop(`Authenticated as ${result.account?.name || result.account?.username || 'unknown'}`);
+        }
+        catch (error) {
+            s.stop();
+            if (error.errorCode === 'user_cancelled' || error.message?.includes('cancelled')) {
+                cancel('Login cancelled.');
+            }
+            throw new Error(`Authentication failed: ${error.message}`);
+        }
+    }
+    else {
+        state.authMethod = 'apikey';
+        let valid = false;
+        while (!valid) {
+            const key = guard(await p.text({
+                message: 'Paste your API key:',
+                validate: v => (!v ? 'API key is required' : undefined),
+            }));
+            const s = p.spinner();
+            s.start('Validating API key...');
+            try {
+                const client = new ApiClient(key, state.apiUrl);
+                await client.get('/workspaces');
+                state.apiKey = key;
+                s.stop('API key validated');
+                valid = true;
+            }
+            catch {
+                s.stop();
+                p.log.error('Invalid API key — please try again.');
+            }
+        }
+    }
+}
+// ─── Step 3 — Workspace ───────────────────────────────────────────────────────
+async function stepWorkspace(state, _detected) {
+    const s = p.spinner();
+    s.start('Loading workspaces...');
+    const client = makeClient(state);
+    const { data: wsData } = await client.get('/workspaces');
+    state.workspaces = wsData.data || wsData || [];
+    s.stop();
+    if (state.workspaces.length === 0) {
+        p.log.warn('No workspaces found in your account.');
+        return;
+    }
+    if (state.workspaces.length === 1) {
+        state.selectedWorkspace = state.workspaces[0];
+        p.log.success(`Workspace: ${state.selectedWorkspace.name}`);
+        return;
+    }
+    const selected = guard(await p.select({
+        message: 'Which workspace would you like to work with today?',
+        options: state.workspaces.map((ws) => ({
+            value: ws.id,
+            label: ws.name,
+            hint: ws.slug,
+        })),
+    }));
+    state.selectedWorkspace = state.workspaces.find((ws) => ws.id === selected) || null;
+}
+// ─── Step 4 — New or existing? ────────────────────────────────────────────────
+async function stepProjectMode(state) {
+    const mode = guard(await p.select({
+        message: 'Are you starting a new project or continuing with an existing one?',
+        options: [
+            { value: 'existing', label: 'Continue with an existing project' },
+            { value: 'new', label: 'Start a new project' },
+        ],
+    }));
+    state.projectMode = mode;
+}
+// ─── Step 4a — Existing project path ─────────────────────────────────────────
+async function stepExistingProject(state) {
+    const client = makeClient(state);
+    const ws = state.selectedWorkspace;
+    const s = p.spinner();
+    s.start('Looking for workflows...');
+    let workflows = [];
+    try {
+        const { data } = await client.get(`/workspaces/${ws.id}/workflows`);
+        workflows = data.data || data || [];
+    }
+    catch {
+        workflows = [];
+    }
+    s.stop();
+    if (workflows.length === 0) {
+        const action = guard(await p.select({
+            message: 'No workflows found in this workspace. What would you like to do?',
+            options: [
+                { value: 'build', label: 'Walk me through building one now' },
+                { value: 'exit', label: 'Exit — I\'ll set things up manually' },
+            ],
+        }));
+        if (action === 'exit') {
+            p.outro('No problem. Run "contextium setup" anytime to come back.');
+            process.exit(0);
+        }
+        return false; // drop into new project path
+    }
+    const options = [
+        ...workflows.map((wf) => {
+            const parts = [];
+            if (wf.agents?.length)
+                parts.push(`${wf.agents.length} agent${wf.agents.length > 1 ? 's' : ''}`);
+            if (wf.projects?.length)
+                parts.push(`${wf.projects.length} librar${wf.projects.length > 1 ? 'ies' : 'y'}`);
+            if (wf.skills?.length)
+                parts.push(`${wf.skills.length} skill${wf.skills.length > 1 ? 's' : ''}`);
+            const hint = parts.join(' + ');
+            return {
+                value: wf.id,
+                label: wf.name,
+                ...(hint ? { hint } : {}),
+            };
+        }),
+        { value: '__none__', label: 'None of these — start fresh' },
+    ];
+    const selected = guard(await p.select({
+        message: `Found ${workflows.length} workflow${workflows.length > 1 ? 's' : ''} — which would you like to load?`,
+        options,
+    }));
+    if (selected === '__none__')
+        return false;
+    state.selectedWorkflow = workflows.find((wf) => wf.id === selected) || null;
+    if (state.selectedWorkflow) {
+        p.note([
+            `Workflow: ${state.selectedWorkflow.name}`,
+            state.selectedWorkflow.agents?.length ? `Agents:   ${state.selectedWorkflow.agents.map((a) => a.name).join(', ')}` : '',
+            state.selectedWorkflow.projects?.length ? `Libraries: ${state.selectedWorkflow.projects.map((p) => p.name).join(', ')}` : '',
+            state.selectedWorkflow.skills?.length ? `Skills:   ${state.selectedWorkflow.skills.map((s) => s.title || s.name).join(', ')}` : '',
+        ].filter(Boolean).join('\n'), 'Workflow loaded');
+    }
+    return true; // done — skip remaining steps
+}
+// ─── Step 4b — New project path ───────────────────────────────────────────────
+async function stepNewProject(state) {
+    const description = guard(await p.text({
+        message: 'What is this project about?',
+        placeholder: 'e.g. Marketing campaign for a new product launch',
+        validate: v => (!v ? 'Please describe your project' : undefined),
+    }));
+    state.projectDescription = description;
+    const suggested = suggestLibraries(state.projectDescription);
+    p.note([
+        'Based on your project, here\'s a suggested layout:',
+        '',
+        ...suggested.map(l => `  • "${l.name}"  — ${l.purpose}`),
+    ].join('\n'), 'Suggested libraries');
+    const libraryAction = guard(await p.select({
+        message: 'What would you like to do with this layout?',
+        options: [
+            { value: 'create', label: `Create ${suggested.length > 1 ? 'these libraries' : 'this library'}` },
+            { value: 'custom', label: 'Let me specify different names' },
+            { value: 'skip', label: 'Skip — I\'ll create libraries myself' },
+        ],
+    }));
+    let librariesToCreate = suggested;
+    if (libraryAction === 'custom') {
+        const count = guard(await p.select({
+            message: 'How many libraries do you need?',
+            options: [
+                { value: '1', label: '1 library' },
+                { value: '2', label: '2 libraries' },
+                { value: '3', label: '3 libraries' },
+            ],
+        }));
+        librariesToCreate = [];
+        for (let i = 0; i < parseInt(count); i++) {
+            const name = guard(await p.text({
+                message: `Library ${i + 1} name:`,
+                validate: v => (!v ? 'Name is required' : undefined),
+            }));
+            const purpose = guard(await p.text({
+                message: `Library ${i + 1} description (optional):`,
+            }));
+            librariesToCreate.push({ name: name, purpose: purpose || '' });
+        }
+    }
+    if (libraryAction !== 'skip') {
+        const client = makeClient(state);
+        const ws = state.selectedWorkspace;
+        const s = p.spinner();
+        s.start(`Creating ${librariesToCreate.length > 1 ? 'libraries' : 'library'}...`);
+        for (const lib of librariesToCreate) {
+            try {
+                const { data } = await client.post(`/workspaces/${ws.id}/projects`, {
+                    name: lib.name,
+                    description: lib.purpose,
+                });
+                state.createdLibraries.push(data.data || data);
+            }
+            catch (error) {
+                s.stop();
+                p.log.warn(`Could not create "${lib.name}": ${error.message}`);
+                s.start('Continuing...');
+            }
+        }
+        s.stop(`Created ${state.createdLibraries.length} ${state.createdLibraries.length > 1 ? 'libraries' : 'library'}`);
+    }
+}
+// ─── Step 5 — Agents ─────────────────────────────────────────────────────────
+async function stepAgents(state) {
+    const client = makeClient(state);
+    const ws = state.selectedWorkspace;
+    const s = p.spinner();
+    s.start('Checking agents...');
+    let agents = [];
+    try {
+        const { data } = await client.get(`/workspaces/${ws.id}/agents`);
+        agents = data.data || data || [];
+    }
+    catch {
+        agents = [];
+    }
+    s.stop();
+    // Score agents against project description
+    const scored = agents
+        .map(a => ({ agent: a, score: scoreMatch(state.projectDescription, a.name, a.description || '') }))
+        .filter(a => a.score > 0)
+        .sort((a, b) => b.score - a.score);
+    const relevantAgents = scored.slice(0, 3).map(s => s.agent);
+    if (relevantAgents.length > 0) {
+        const options = [
+            ...relevantAgents.map((a) => ({
+                value: a.id,
+                label: a.name,
+                hint: a.description || undefined,
+            })),
+            { value: '__marketplace__', label: 'None of these — look in the marketplace' },
+            { value: '__custom__', label: 'Create a custom agent' },
+            { value: '__skip__', label: 'Skip agents for now' },
+        ];
+        const selected = guard(await p.select({
+            message: `Agents in your workspace that match this project:`,
+            options,
+        }));
+        if (selected === '__skip__')
+            return;
+        if (selected === '__marketplace__')
+            return await stepAgentsMarketplace(state, client, ws);
+        if (selected === '__custom__')
+            return await stepCreateAgent(state, client, ws);
+        const agent = agents.find((a) => a.id === selected);
+        if (agent)
+            state.selectedAgents.push(agent);
+    }
+    else {
+        p.log.info('No matching agents found in your workspace.');
+        const action = guard(await p.select({
+            message: 'What would you like to do?',
+            options: [
+                { value: 'marketplace', label: 'Browse Contextium Marketplace for agents' },
+                { value: 'custom', label: 'Create a custom agent' },
+                { value: 'skip', label: 'Skip for now' },
+            ],
+        }));
+        if (action === 'marketplace')
+            return await stepAgentsMarketplace(state, client, ws);
+        if (action === 'custom')
+            return await stepCreateAgent(state, client, ws);
+    }
+}
+async function stepAgentsMarketplace(state, client, ws) {
+    const query = state.projectDescription.split(' ').slice(0, 4).join(' ');
+    const s = p.spinner();
+    s.start('Searching marketplace for agents...');
+    let listings = [];
+    try {
+        const { data } = await client.get('/marketplace/listings', { params: { q: query, type: 'agent' } });
+        listings = (data.data || data || []).slice(0, 5);
+    }
+    catch {
+        listings = [];
+    }
+    s.stop();
+    if (listings.length === 0) {
+        p.log.info('No matching agents found in the marketplace.');
+        const createOne = guard(await p.confirm({ message: 'Would you like to create a custom agent instead?' }));
+        if (createOne)
+            return await stepCreateAgent(state, client, ws);
+        return;
+    }
+    const selected = guard(await p.select({
+        message: `Marketplace agents for "${query}":`,
+        options: [
+            ...listings.map((l) => ({
+                value: l.slug,
+                label: l.name,
+                hint: l.shortDescription || undefined,
+            })),
+            { value: '__skip__', label: 'Skip — none of these' },
+        ],
+    }));
+    if (selected === '__skip__')
+        return;
+    const s2 = p.spinner();
+    s2.start(`Installing ${selected}...`);
+    try {
+        const { data } = await client.post(`/marketplace/listings/${selected}/import`, { workspaceId: ws.id });
+        const result = data.data || data;
+        const agent = result.agent || result;
+        state.selectedAgents.push(agent);
+        state.newAgents.push(agent);
+        s2.stop(`Installed: ${agent.name || selected}`);
+    }
+    catch (error) {
+        s2.stop();
+        p.log.error(`Install failed: ${error.message}`);
+    }
+}
+async function stepCreateAgent(state, client, ws) {
+    const name = guard(await p.text({
+        message: 'Agent name:',
+        validate: v => (!v ? 'Name is required' : undefined),
+    }));
+    const description = guard(await p.text({
+        message: 'Description:',
+        placeholder: 'What does this agent help with?',
+    }));
+    const prompt = guard(await p.text({
+        message: 'System prompt:',
+        placeholder: `You are ${name}. ${description}`,
+    }));
+    const s = p.spinner();
+    s.start('Creating agent...');
+    try {
+        const { data } = await client.post(`/workspaces/${ws.id}/agents`, {
+            name,
+            description,
+            systemPrompt: prompt || `You are ${name}. ${description}`,
+        });
+        const agent = data.data || data;
+        state.selectedAgents.push(agent);
+        state.newAgents.push(agent);
+        s.stop(`Agent created: ${agent.name}`);
+    }
+    catch (error) {
+        s.stop();
+        p.log.error(`Failed to create agent: ${error.message}`);
+    }
+}
+// ─── Step 6 — Skills ─────────────────────────────────────────────────────────
+async function stepSkills(state) {
+    const client = makeClient(state);
+    const ws = state.selectedWorkspace;
+    const s = p.spinner();
+    s.start('Checking skills...');
+    let skills = [];
+    try {
+        const { data: projectsData } = await client.get(`/workspaces/${ws.id}/projects`);
+        const projects = projectsData.data || projectsData || [];
+        const skillsProject = projects.find((p) => p.isSystem && p.systemType === 'skills');
+        if (skillsProject) {
+            const { data: filesData } = await client.get(`/projects/${skillsProject.id}/files`);
+            skills = (filesData.data || filesData || []).filter((f) => !f.deletedAt);
+        }
+    }
+    catch {
+        skills = [];
+    }
+    s.stop();
+    const scored = skills
+        .map(sk => ({ skill: sk, score: scoreMatch(state.projectDescription, sk.title, '') }))
+        .filter(s => s.score > 0)
+        .sort((a, b) => b.score - a.score);
+    const relevantSkills = scored.slice(0, 3).map(s => s.skill);
+    if (relevantSkills.length > 0) {
+        const selected = guard(await p.select({
+            message: 'Relevant skills found in your workspace:',
+            options: [
+                ...relevantSkills.map((sk) => ({
+                    value: sk.id,
+                    label: sk.title,
+                })),
+                { value: '__marketplace__', label: 'Browse marketplace for more skills' },
+                { value: '__custom__', label: 'Create a custom skill' },
+                { value: '__skip__', label: 'Skip skills for now' },
+            ],
+        }));
+        if (selected === '__skip__')
+            return;
+        if (selected === '__marketplace__')
+            return await stepSkillsMarketplace(state, client, ws);
+        if (selected === '__custom__')
+            return await stepCreateSkill(state, client, ws);
+        const skill = skills.find((sk) => sk.id === selected);
+        if (skill)
+            await connectSkill(state, client, ws, skill, false);
+    }
+    else {
+        p.log.info('No matching skills found in your workspace.');
+        const action = guard(await p.select({
+            message: 'What would you like to do?',
+            options: [
+                { value: 'marketplace', label: 'Browse Contextium Marketplace for skills' },
+                { value: 'custom', label: 'Create a custom skill' },
+                { value: 'skip', label: 'Skip for now' },
+            ],
+        }));
+        if (action === 'marketplace')
+            return await stepSkillsMarketplace(state, client, ws);
+        if (action === 'custom')
+            return await stepCreateSkill(state, client, ws);
+    }
+}
+async function stepSkillsMarketplace(state, client, ws) {
+    const query = state.projectDescription.split(' ').slice(0, 4).join(' ');
+    const s = p.spinner();
+    s.start('Searching marketplace for skills...');
+    let listings = [];
+    try {
+        const { data } = await client.get('/marketplace/listings', { params: { q: query, type: 'skill' } });
+        listings = (data.data || data || []).slice(0, 5);
+    }
+    catch {
+        listings = [];
+    }
+    s.stop();
+    if (listings.length === 0) {
+        p.log.info('No matching skills found in the marketplace.');
+        const createOne = guard(await p.confirm({ message: 'Would you like to create a custom skill instead?' }));
+        if (createOne)
+            return await stepCreateSkill(state, client, ws);
+        return;
+    }
+    const selected = guard(await p.select({
+        message: `Marketplace skills for "${query}":`,
+        options: [
+            ...listings.map((l) => ({
+                value: l.slug,
+                label: l.name,
+                hint: l.shortDescription || undefined,
+            })),
+            { value: '__skip__', label: 'Skip — none of these' },
+        ],
+    }));
+    if (selected === '__skip__')
+        return;
+    const s2 = p.spinner();
+    s2.start(`Installing ${selected}...`);
+    try {
+        const { data } = await client.post(`/marketplace/listings/${selected}/import`, { workspaceId: ws.id });
+        const result = data.data || data;
+        const skill = result.skill || result;
+        s2.stop(`Installed: ${skill.title || skill.name || selected}`);
+        await connectSkill(state, client, ws, skill, true);
+    }
+    catch (error) {
+        s2.stop();
+        p.log.error(`Install failed: ${error.message}`);
+    }
+}
+async function stepCreateSkill(state, client, ws) {
+    const name = guard(await p.text({
+        message: 'Skill name:',
+        validate: v => (!v ? 'Name is required' : undefined),
+    }));
+    const description = guard(await p.text({
+        message: 'Description:',
+        placeholder: 'What does this skill teach the agent?',
+    }));
+    const content = guard(await p.text({
+        message: 'Skill content/instructions:',
+        placeholder: 'Write the instructions, guidelines, or knowledge this skill provides...',
+        validate: v => (!v ? 'Content is required — skills must have instructions' : undefined),
+    }));
+    const s = p.spinner();
+    s.start('Creating skill...');
+    try {
+        const { data: projectsData } = await client.get(`/workspaces/${ws.id}/projects`);
+        const projects = projectsData.data || projectsData || [];
+        const skillsProject = projects.find((p) => p.isSystem && p.systemType === 'skills');
+        if (!skillsProject)
+            throw new Error('Skills Library not found in workspace');
+        const slug = name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '').replace(/-+/g, '-').replace(/^-|-$/g, '');
+        const { data: fileData } = await client.post(`/projects/${skillsProject.id}/files`, {
+            title: name,
+            path: `${slug}.md`,
+            content: `# ${name}\n\n${description}\n\n${content}`,
+        });
+        const skill = fileData.data || fileData;
+        state.newSkills.push(skill);
+        s.stop(`Skill created: ${skill.title}`);
+        await connectSkill(state, client, ws, skill, true);
+    }
+    catch (error) {
+        s.stop();
+        p.log.error(`Failed to create skill: ${error.message}`);
+    }
+}
+async function connectSkill(state, client, ws, skill, _isNew) {
+    if (state.selectedAgents.length === 0) {
+        state.standaloneSkills.push(skill);
+        return;
+    }
+    const agent = state.selectedAgents[0];
+    const isNewAgent = state.newAgents.some((a) => a.id === agent.id);
+    if (isNewAgent) {
+        const attach = guard(await p.confirm({
+            message: `Attach "${skill.title || skill.name}" to your new agent "${agent.name}"?`,
+            initialValue: true,
+        }));
+        if (attach) {
+            await doAttachSkill(state, client, ws, agent, skill);
+        }
+        else {
+            state.standaloneSkills.push(skill);
+        }
+    }
+    else {
+        const action = guard(await p.select({
+            message: `"${agent.name}" is an existing agent used across projects. How should this skill be added?`,
+            options: [
+                { value: 'workflow', label: 'Add to this workflow only', hint: 'recommended' },
+                { value: 'agent', label: 'Add it to the agent (affects all projects using this agent)' },
+                { value: 'skip', label: 'Skip' },
+            ],
+        }));
+        if (action === 'agent') {
+            await doAttachSkill(state, client, ws, agent, skill);
+        }
+        else if (action === 'workflow') {
+            state.standaloneSkills.push(skill);
+        }
+    }
+}
+async function doAttachSkill(state, client, ws, agent, skill) {
+    const s = p.spinner();
+    s.start(`Attaching skill to ${agent.name}...`);
+    try {
+        await client.post(`/workspaces/${ws.id}/agents/${agent.id}/skills`, { skillId: skill.id });
+        state.selectedSkills.push(skill);
+        s.stop('Skill attached');
+    }
+    catch (error) {
+        s.stop();
+        p.log.warn(`Could not attach skill: ${error.message} — adding to workflow instead`);
+        state.standaloneSkills.push(skill);
+    }
+}
+// ─── Step 7 — Build the workflow ──────────────────────────────────────────────
+async function stepBuildWorkflow(state) {
+    const hasAnything = state.selectedAgents.length > 0 || state.standaloneSkills.length > 0 || state.createdLibraries.length > 0;
+    if (!hasAnything) {
+        p.log.info('Nothing to bundle into a workflow — skipping workflow creation.');
+        return;
+    }
+    const summaryLines = [
+        state.selectedAgents.length ? `Agents:    ${state.selectedAgents.map((a) => a.name).join(', ')}` : '',
+        state.selectedSkills.length ? `Skills:    ${state.selectedSkills.map((s) => s.title || s.name).join(', ')} (via agent)` : '',
+        state.standaloneSkills.length ? `Skills:    ${state.standaloneSkills.map((s) => s.title || s.name).join(', ')} (standalone)` : '',
+        state.createdLibraries.length ? `Libraries: ${state.createdLibraries.map((l) => l.name).join(', ')}` : '',
+    ].filter(Boolean);
+    p.note(summaryLines.join('\n'), 'Workflow contents');
+    const action = guard(await p.select({
+        message: 'Ready to create your workflow?',
+        options: [
+            { value: 'create', label: 'Create this workflow' },
+            { value: 'skip', label: 'Skip — I\'ll create the workflow manually' },
+        ],
+    }));
+    if (action === 'skip')
+        return;
+    const defaultName = state.projectDescription
+        ? state.projectDescription.split(' ').slice(0, 4).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')
+        : 'My Workflow';
+    const workflowName = guard(await p.text({
+        message: 'Workflow name:',
+        initialValue: defaultName,
+        validate: v => (!v ? 'Name is required' : undefined),
+    }));
+    const client = makeClient(state);
+    const ws = state.selectedWorkspace;
+    const s = p.spinner();
+    s.start('Creating workflow...');
+    try {
+        const payload = { name: workflowName };
+        if (state.selectedAgents.length)
+            payload.agentIds = state.selectedAgents.map((a) => a.id);
+        if (state.standaloneSkills.length)
+            payload.skillIds = state.standaloneSkills.map((s) => s.id);
+        if (state.createdLibraries.length)
+            payload.projectIds = state.createdLibraries.map((l) => l.id);
+        const { data } = await client.post(`/workspaces/${ws.id}/workflows`, payload);
+        state.createdWorkflow = data.data || data;
+        s.stop(`Workflow created: ${state.createdWorkflow.name}`);
+    }
+    catch (error) {
+        s.stop();
+        p.log.error(`Failed to create workflow: ${error.message}`);
+    }
+}
+// ─── Step 8 — Write config ────────────────────────────────────────────────────
+async function stepWriteConfig(state, detected) {
+    if (detected.hasConfig) {
+        const overwrite = guard(await p.confirm({
+            message: 'A .contextiumrc already exists here. Update it?',
+            initialValue: true,
+        }));
+        if (!overwrite) {
+            p.log.info('Keeping existing .contextiumrc');
+            state.configWritten = false;
+            return;
+        }
+    }
+    const config = {
+        api_key: state.apiKey || '',
+        api_url: state.apiUrl || DEFAULT_API_URL,
+        ...(state.selectedWorkspace && {
+            workspace_id: state.selectedWorkspace.id,
+            workspace: state.selectedWorkspace.slug,
+        }),
+        cache: { enabled: true, ttl: 3600, directory: '.contextium-cache', max_size_mb: 100 },
+        sync: { auto: true, on_command: ['build', 'test'], notify_changes: true, interval: 300 },
+        files: { include: [], exclude: [], tags: [], auto_include_tags: true },
+    };
+    await saveConfig(config);
+    // Create cache dir and update .gitignore
+    await fs.mkdir(path.join(process.cwd(), '.contextium-cache'), { recursive: true });
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    try {
+        let gitignore = await fs.readFile(gitignorePath, 'utf-8');
+        if (!gitignore.includes('.contextium-cache')) {
+            gitignore += '\n.contextium-cache/\n.contextiumrc\n';
+            await fs.writeFile(gitignorePath, gitignore);
+        }
+    }
+    catch {
+        await fs.writeFile(gitignorePath, '.contextium-cache/\n.contextiumrc\n');
+    }
+    state.configWritten = true;
+    p.log.success('Config written to .contextiumrc');
+}
+// ─── Step 9 — Claude Code setup ───────────────────────────────────────────────
+async function stepClaudeCode(state, detected) {
+    if (detected.isClaudeConfigured) {
+        p.log.success('Claude Code permissions already configured');
+        state.claudeConfigured = true;
+        return;
+    }
+    const useClaude = guard(await p.confirm({
+        message: 'Do you use Claude Code (claude.ai/claude-code)?',
+        initialValue: true,
+    }));
+    if (!useClaude)
+        return;
+    const scope = guard(await p.select({
+        message: 'Where should permissions be configured?',
+        options: [
+            { value: 'global', label: 'Global (~/.claude/settings.json)', hint: 'applies to all projects' },
+            { value: 'project', label: 'Project (.claude/settings.json)', hint: 'this project only' },
+        ],
+    }));
+    const s = p.spinner();
+    s.start('Configuring Claude Code permissions...');
+    try {
+        await addClaudePermission(scope);
+        state.claudeConfigured = true;
+        s.stop('Claude Code permissions configured');
+    }
+    catch (error) {
+        s.stop();
+        p.log.error(`Failed to configure Claude Code: ${error.message}`);
+    }
+}
+// ─── Step 10 — Outro ─────────────────────────────────────────────────────────
+function stepOutro(state) {
+    const lines = [];
+    if (state.account)
+        lines.push(`Authenticated as:  ${state.account.name || state.account.username}`);
+    if (state.selectedWorkspace)
+        lines.push(`Workspace:         ${state.selectedWorkspace.name}`);
+    if (state.createdLibraries.length)
+        lines.push(`Libraries created: ${state.createdLibraries.map((l) => l.name).join(', ')}`);
+    if (state.createdWorkflow)
+        lines.push(`Workflow created:  ${state.createdWorkflow.name}`);
+    if (state.selectedWorkflow)
+        lines.push(`Workflow loaded:   ${state.selectedWorkflow.name}`);
+    if (state.configWritten)
+        lines.push(`Config written:    .contextiumrc`);
+    if (state.claudeConfigured)
+        lines.push(`Claude Code:       permissions configured`);
+    if (state.claudeConfigured) {
+        lines.push('');
+        lines.push('Available /ium: commands in Claude Code:');
+        lines.push('  /ium:setup      Run this wizard again');
+        lines.push('  /ium:workflow   Load a workflow into context');
+        lines.push('  /ium:new        Create a new file');
+        lines.push('  /ium:search     Search your documentation');
+    }
+    const ws = state.selectedWorkspace?.slug || state.selectedWorkspace?.name || 'my-workspace';
+    const wf = state.createdWorkflow?.name || state.selectedWorkflow?.name;
+    lines.push('');
+    lines.push('Next steps:');
+    if (wf)
+        lines.push(`  contextium workflow "${wf}" --sync`);
+    lines.push(`  contextium libraries -w ${ws}`);
+    lines.push(`  contextium cat --all -w ${ws}`);
+    p.note(lines.join('\n'), "You're all set!");
+    p.outro('Happy building with Contextium.');
+}
+// ─── Main entry point ─────────────────────────────────────────────────────────
+export async function runWizard(options) {
+    p.intro('Contextium Setup');
+    let detected;
+    try {
+        detected = await detectState(options.force);
+    }
+    catch (error) {
+        p.log.error(`Setup error: ${error.message}`);
+        process.exit(1);
+    }
+    const state = createInitialState();
+    // Step 2 — Auth
+    await stepAuth(state, detected);
+    // Step 3 — Workspace
+    if (!state.selectedWorkspace) {
+        if (!detected.hasWorkspace || options.force) {
+            await stepWorkspace(state, detected);
+        }
+        else if (detected.existingConfig?.workspace_id) {
+            state.selectedWorkspace = {
+                id: detected.existingConfig.workspace_id,
+                slug: detected.existingConfig.workspace,
+                name: detected.existingConfig.workspace || detected.existingConfig.workspace_id,
+            };
+            p.log.success(`Workspace: ${state.selectedWorkspace.name}`);
+        }
+    }
+    if (!state.selectedWorkspace) {
+        p.log.warn('No workspace selected — skipping project steps.');
+        await stepWriteConfig(state, detected);
+        await stepClaudeCode(state, detected);
+        stepOutro(state);
+        return;
+    }
+    // Step 4 — New or existing project?
+    await stepProjectMode(state);
+    let doneAfterWorkflowLoad = false;
+    if (state.projectMode === 'existing') {
+        doneAfterWorkflowLoad = await stepExistingProject(state);
+    }
+    if (!doneAfterWorkflowLoad) {
+        // Step 4b — New project setup
+        if (state.projectMode === 'new' || !doneAfterWorkflowLoad) {
+            await stepNewProject(state);
+        }
+        // Step 5 — Agents
+        await stepAgents(state);
+        // Step 6 — Skills
+        await stepSkills(state);
+        // Step 7 — Build workflow
+        await stepBuildWorkflow(state);
+    }
+    // Step 8 — Write config
+    await stepWriteConfig(state, detected);
+    // Step 9 — Claude Code
+    await stepClaudeCode(state, detected);
+    // Step 10 — Summary
+    stepOutro(state);
+}
+//# sourceMappingURL=wizard.js.map