gipity 1.0.408 → 1.0.409

package/dist/commands/hook-capture.js

@@ -1,215 +0,0 @@
-/**
- * Hidden subcommand invoked by Claude Code hooks (see setup.ts HOOKS_SETTINGS).
- * Reads Claude's hook JSON on stdin and POSTs a capture event to Gipity.
- *
- * The target conversation is identified by the `GIPITY_CONVERSATION_GUID`
- * env var, which `gipity claude` exports before spawning Claude Code.
- * Every capture event is tagged with that conv_guid — no server-side
- * placeholder adoption, no guessing.
- *
- * Must never fail loudly — a hook that errors would degrade Claude Code's
- * UX. All errors are swallowed (optionally logged to
- * .gipity/hook-capture.log for debugging).
- */
-import { Command } from 'commander';
-import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, appendFileSync } from 'fs';
-import { resolve, dirname } from 'path';
-import { getConfig } from '../config.js';
-import { getAuth } from '../auth.js';
-import { post } from '../api.js';
-function readStdin() {
-    return new Promise((r) => {
-        let data = '';
-        process.stdin.setEncoding('utf-8');
-        process.stdin.on('data', (c) => (data += c));
-        process.stdin.on('end', () => r(data));
-        process.stdin.on('error', () => r(data));
-    });
-}
-function debugLog(msg) {
-    if (!process.env.GIPITY_HOOK_DEBUG)
-        return;
-    try {
-        const cfg = getConfig();
-        if (!cfg)
-            return;
-        const logPath = resolve(process.cwd(), '.gipity', 'hook-capture.log');
-        mkdirSync(dirname(logPath), { recursive: true });
-        appendFileSync(logPath, `${new Date().toISOString()} ${msg}\n`);
-    }
-    catch { /* ignore */ }
-}
-const TTY = !!process.stderr.isTTY;
-const dim = (s) => TTY ? `\x1b[2m${s}\x1b[0m` : s;
-const cyan = (s) => TTY ? `\x1b[36m${s}\x1b[0m` : s;
-const red = (s) => TTY ? `\x1b[31m${s}\x1b[0m` : s;
-function hhmmss() {
-    const d = new Date();
-    const p = (n) => String(n).padStart(2, '0');
-    return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
-}
-function friendlyLabel(path) {
-    const m = path.match(/\/remote-sessions\/[^/]+\/(.+)$/);
-    return m ? m[1] : path;
-}
-function summarize(body) {
-    if (!body || typeof body !== 'object')
-        return '';
-    const b = body;
-    if (typeof b.prompt === 'string') {
-        const p = b.prompt.replace(/\s+/g, ' ').trim();
-        return p.length > 80 ? `"${p.slice(0, 77)}…"` : `"${p}"`;
-    }
-    if (typeof b.tool_name === 'string')
-        return b.tool_name;
-    if (Array.isArray(b.entries))
-        return `${b.entries.length} transcript entr${b.entries.length === 1 ? 'y' : 'ies'}`;
-    if (typeof b.trigger === 'string')
-        return b.trigger;
-    if (typeof b.source === 'string')
-        return b.source;
-    return '';
-}
-async function safePost(path, body) {
-    const label = friendlyLabel(path);
-    const detail = summarize(body);
-    process.stderr.write(`${dim(hhmmss())} ${cyan('↗ gipity')}  ${label}${detail ? '  ' + dim(detail) : ''}\n`);
-    try {
-        await post(path, body);
-    }
-    catch (err) {
-        process.stderr.write(`${dim(hhmmss())} ${red('✗ gipity')}  ${label}  ${dim(err?.message || String(err))}\n`);
-        debugLog(`POST ${path} failed: ${err?.message || err}`);
-    }
-}
-function offsetPath(sessionId) {
-    return resolve(process.cwd(), '.gipity', 'transcripts', `${sessionId}.offset`);
-}
-function readOffset(sessionId) {
-    try {
-        return parseInt(readFileSync(offsetPath(sessionId), 'utf-8'), 10) || 0;
-    }
-    catch {
-        return 0;
-    }
-}
-function writeOffset(sessionId, offset) {
-    const p = offsetPath(sessionId);
-    mkdirSync(dirname(p), { recursive: true });
-    writeFileSync(p, String(offset));
-}
-/** Parse JSONL delta from transcript_path starting at stored offset. */
-function readTranscriptDelta(transcriptPath, sessionId) {
-    if (!existsSync(transcriptPath))
-        return { entries: [], newOffset: 0 };
-    const size = statSync(transcriptPath).size;
-    let offset = readOffset(sessionId);
-    if (offset > size)
-        offset = 0; // regressed — rescan
-    if (offset === size)
-        return { entries: [], newOffset: offset };
-    const fd = readFileSync(transcriptPath);
-    const slice = fd.slice(offset).toString('utf-8');
-    const lines = slice.split('\n').filter((l) => l.trim());
-    const entries = [];
-    for (const line of lines) {
-        try {
-            entries.push(JSON.parse(line));
-        }
-        catch { /* skip partial */ }
-    }
-    return { entries, newOffset: size };
-}
-/** Preflight: hooks are no-ops when we're not in a Gipity project, not
- *  authed, or (crucially) when the parent `gipity claude` never exported
- *  a conv_guid (unpaired device, failed create, etc.). Without the
- *  conv_guid there is no conversation to attach events to. */
-function preflight() {
-    if (!getConfig())
-        return null;
-    if (!getAuth())
-        return null;
-    const convGuid = process.env.GIPITY_CONVERSATION_GUID;
-    if (!convGuid)
-        return null;
-    return { convGuid };
-}
-async function handleStart(payload, convGuid) {
-    const { session_id, cwd, source } = payload;
-    if (!session_id)
-        return;
-    // Attach this Claude Code run's session_id to the conv. Idempotent
-    // server-side; harmless to call multiple times (e.g. after --resume).
-    await safePost(`/remote-sessions/${encodeURIComponent(convGuid)}/attach-session`, {
-        session_id,
-        cwd: cwd || process.cwd(),
-        source: source || 'startup',
-    });
-}
-async function handlePrompt(payload, convGuid) {
-    const { prompt } = payload;
-    await safePost(`/remote-sessions/${encodeURIComponent(convGuid)}/prompt`, {
-        prompt: prompt || '',
-        ts: new Date().toISOString(),
-    });
-}
-async function handleTool(payload, convGuid) {
-    const { tool_name, tool_input, tool_response } = payload;
-    if (!tool_name)
-        return;
-    await safePost(`/remote-sessions/${encodeURIComponent(convGuid)}/tool`, {
-        tool_name,
-        tool_input: tool_input ?? null,
-        tool_response: tool_response ?? null,
-    });
-}
-async function handleStop(payload, convGuid) {
-    const { session_id, transcript_path } = payload;
-    if (!session_id || !transcript_path)
-        return;
-    const { entries, newOffset } = readTranscriptDelta(transcript_path, session_id);
-    if (entries.length === 0)
-        return;
-    await safePost(`/remote-sessions/${encodeURIComponent(convGuid)}/transcript`, { entries });
-    writeOffset(session_id, newOffset);
-}
-async function handleEnd(_payload, convGuid) {
-    await safePost(`/remote-sessions/${encodeURIComponent(convGuid)}/end`, {});
-}
-async function handleCompact(payload, convGuid) {
-    const { trigger } = payload;
-    await safePost(`/remote-sessions/${encodeURIComponent(convGuid)}/compact`, {
-        trigger: trigger || 'auto',
-    });
-}
-async function run(event) {
-    const pre = preflight();
-    if (!pre)
-        return;
-    const raw = await readStdin();
-    let payload;
-    try {
-        payload = JSON.parse(raw);
-    }
-    catch {
-        debugLog(`bad JSON on ${event}`);
-        return;
-    }
-    switch (event) {
-        case 'start': return handleStart(payload, pre.convGuid);
-        case 'prompt': return handlePrompt(payload, pre.convGuid);
-        case 'tool': return handleTool(payload, pre.convGuid);
-        case 'stop': return handleStop(payload, pre.convGuid);
-        case 'end': return handleEnd(payload, pre.convGuid);
-        case 'compact': return handleCompact(payload, pre.convGuid);
-    }
-}
-export const hookCaptureCommand = new Command('hook-capture')
-    .description('Internal: capture Claude Code hook events and forward to Gipity')
-    .argument('<event>', 'hook event: start|prompt|tool|stop|end|compact')
-    .action(async (event) => {
-    await run(event);
-    // Always succeed quietly — hooks must not surface errors to Claude Code.
-    process.exit(0);
-});
-//# sourceMappingURL=hook-capture.js.map

package/dist/commands/scaffold.js

@@ -1,58 +0,0 @@
-import { Command } from 'commander';
-import { post } from '../api.js';
-import { requireConfig } from '../config.js';
-import { sync } from '../sync.js';
-import { success } from '../colors.js';
-import { run } from '../helpers/index.js';
-// Scaffold types grouped by kind. Mirrors SCAFFOLD_TEMPLATES in
-// platform/packages/shared - kept inline here because the CLI is published
-// as a standalone npm package and can't depend on the private shared
-// workspace. When adding/removing/promoting an entry, update both lists.
-//
-// Templates are minimal wiring (start fresh). Starter apps are working demos.
-// Hidden entries are accepted by the server but not suggested by default -
-// they're shown to the agent in a "do-not-suggest-unsolicited" line so the
-// LLM can still pick one when the user asks for that domain by name.
-const VISIBLE_TEMPLATES = ['web-simple', '3d-engine'];
-const VISIBLE_STARTERS = ['web-fullstack', '2d-game', '3d-world', 'api'];
-const HIDDEN_STARTERS = [
-    { key: 'app-itsm', hint: 'IT service management / helpdesk / ticketing / incident management' },
-];
-const visibleTypeList = [
-    `templates: ${VISIBLE_TEMPLATES.join(', ')}`,
-    `starters: ${VISIBLE_STARTERS.join(', ')}`,
-].join(' | ');
-const hiddenTypeList = HIDDEN_STARTERS.length
-    ? ' | hidden (do NOT suggest unsolicited; use only when the user explicitly asks for that domain): ' +
-        HIDDEN_STARTERS.map(h => `${h.key} (${h.hint})`).join(', ')
-    : '';
-export const scaffoldCommand = new Command('scaffold')
-    .description('Create an app from a template')
-    .argument('[title]', 'App title (defaults to project name)')
-    .requiredOption('--type <type>', `Project type: ${visibleTypeList}${hiddenTypeList}`)
-    .option('--description <desc>', 'App description for meta tags')
-    .option('--json', 'Output as JSON')
-    .action((title, opts) => run('Scaffold', async () => {
-    const config = requireConfig();
-    const appTitle = title || config.projectSlug;
-    const res = await post(`/projects/${config.projectGuid}/scaffold`, {
-        title: appTitle,
-        description: opts.description,
-        type: opts.type,
-    });
-    // Sync down the created files
-    const syncResult = await sync({ interactive: false });
-    if (opts.json) {
-        console.log(JSON.stringify({ ...res.data, synced: syncResult.applied }));
-    }
-    else {
-        console.log(success(`Scaffolded "${res.data.title}" with ${res.data.files.length} files:`));
-        for (const f of res.data.files) {
-            console.log(`  ${f}`);
-        }
-        if (syncResult.applied > 0) {
-            console.log(`\nPulled ${syncResult.applied} files to local.`);
-        }
-    }
-}));
-//# sourceMappingURL=scaffold.js.map

package/dist/commands/skills.js

@@ -1,45 +0,0 @@
-import { Command } from 'commander';
-import { get } from '../api.js';
-import { resolveProjectContext } from '../config.js';
-import { error as clrError, bold, muted } from '../colors.js';
-import { run, printList } from '../helpers/index.js';
-export const skillsCommand = new Command('skills')
-    .description('Read platform docs');
-skillsCommand
-    .command('list')
-    .description('List skills')
-    .option('--json', 'Output as JSON')
-    .action((opts) => run('List', async () => {
-    const { config } = await resolveProjectContext();
-    if (!config.agentGuid) {
-        console.error(clrError('No agent configured for this project. Run `gipity init` to refresh.'));
-        process.exit(1);
-    }
-    const res = await get(`/skills?agent=${config.agentGuid}`);
-    printList(res.data, opts, 'No skills available.', s => `${bold(s.name)}  ${muted(s.description)}`);
-}));
-skillsCommand
-    .command('read <name>')
-    .description('Read a skill')
-    .option('--json', 'Output as JSON')
-    .action((name, opts) => run('Read', async () => {
-    const { config } = await resolveProjectContext();
-    if (!config.agentGuid) {
-        console.error(clrError('No agent configured for this project. Run `gipity init` to refresh.'));
-        process.exit(1);
-    }
-    const listRes = await get(`/skills?agent=${config.agentGuid}`);
-    const match = listRes.data.find(s => s.name.toLowerCase() === name.toLowerCase());
-    if (!match) {
-        console.error(clrError(`Skill "${name}" not found. Run: gipity skills list`));
-        process.exit(1);
-    }
-    const res = await get(`/skills/${match.guid}?agent=${config.agentGuid}`);
-    if (opts.json) {
-        console.log(JSON.stringify(res.data, null, 2));
-    }
-    else {
-        console.log(res.data.content);
-    }
-}));
-//# sourceMappingURL=skills.js.map

package/dist/commands/start-cc.js

@@ -1,313 +0,0 @@
-import { Command } from 'commander';
-import { join } from 'path';
-import { mkdirSync } from 'fs';
-import { execSync, spawn } from 'child_process';
-import { homedir } from 'os';
-/** On Windows, spawn without shell:true needs an explicit extension (.exe or .cmd) */
-function resolveCommand(cmd) {
-    if (process.platform !== 'win32')
-        return cmd;
-    try {
-        const lines = execSync(`where ${cmd}`, { encoding: 'utf-8' }).split(/\r?\n/).map(l => l.trim()).filter(Boolean);
-        // Prefer .exe (native) over .cmd (npm shim)
-        return lines.find(l => l.endsWith('.exe')) || lines.find(l => l.endsWith('.cmd')) || cmd;
-    }
-    catch {
-        return `${cmd}.cmd`;
-    }
-}
-import { getAuth, saveAuth } from '../auth.js';
-import { get, post, publicPost } from '../api.js';
-import { getConfig, saveConfig, clearConfigCache, getApiBaseOverride } from '../config.js';
-import { syncDown, syncUp } from '../sync.js';
-import { slugify, setupClaudeHooks, setupClaudeMd, setupGitignore } from '../setup.js';
-import { prompt, pickOne, decodeJwtExp } from '../utils.js';
-import { brand, bold, faint, info, success, error as clrError, muted } from '../colors.js';
-const PROJECTS_ROOT = join(homedir(), 'GipityProjects');
-function suggestProjectName(existingSlugs) {
-    const slugSet = new Set(existingSlugs);
-    for (let i = 1; i <= 99; i++) {
-        const candidate = `project${String(i).padStart(2, '0')}`;
-        if (!slugSet.has(candidate))
-            return candidate;
-    }
-    return `project-${Date.now().toString(36).slice(-6)}`;
-}
-export const startCcCommand = new Command('start-cc')
-    .description('Log in, set up a project, and launch Claude Code')
-    .option('--no-claude', 'Set up project but skip launching Claude Code')
-    .allowUnknownOption(true)
-    .allowExcessArguments(true)
-    .action(async (opts) => {
-    try {
-        console.log(`\n  ${brand(bold('Welcome to Gipity'))}`);
-        console.log(`  ${faint('─────────────────')}`);
-        console.log('');
-        // ── Step 1: Auth ──────────────────────────────────────────────────
-        let auth = getAuth();
-        if (auth) {
-            console.log(`  Logged in as ${auth.email}`);
-        }
-        else {
-            console.log('  Let\'s get you logged in.\n');
-            const email = await prompt('  Email: ');
-            if (!email) {
-                console.error(`\n  ${clrError('Email required.')}`);
-                process.exit(1);
-            }
-            await publicPost('/auth/login', { email });
-            console.log('  Check your email for a 6-digit code.\n');
-            const code = await prompt('  Code: ');
-            if (!code) {
-                console.error(`\n  ${clrError('Code required.')}`);
-                process.exit(1);
-            }
-            const res = await publicPost('/auth/verify', { email, code });
-            const exp = decodeJwtExp(res.accessToken);
-            if (!exp) {
-                console.error(`\n  ${clrError('Invalid token received.')}`);
-                process.exit(1);
-            }
-            const expiresAt = new Date(exp * 1000).toISOString();
-            saveAuth({ accessToken: res.accessToken, refreshToken: res.refreshToken, email, expiresAt });
-            auth = getAuth();
-            console.log(`  ${success(`Logged in as ${email}`)}`);
-        }
-        console.log('');
-        // ── Step 2: Project ───────────────────────────────────────────────
-        let initialPrompt = '';
-        // If cwd already has .gipity.json, use it (user ran from inside a project)
-        const existing = getConfig();
-        if (existing) {
-            console.log(`  Project: ${brand(existing.projectSlug)} ${muted(`(${existing.projectGuid})`)}`);
-            console.log(`  ${success('Already set up.')}\n`);
-            setupClaudeHooks();
-            setupClaudeMd();
-            setupGitignore();
-        }
-        else {
-            // Fetch user's projects
-            let projects = [];
-            let fetchFailed = false;
-            try {
-                const res = await get('/projects?limit=100');
-                projects = res.data;
-            }
-            catch (err) {
-                fetchFailed = true;
-                const isConnectionError = err?.code === 'ECONNREFUSED' || err?.code === 'ENOTFOUND' ||
-                    err?.code === 'ETIMEDOUT' || err?.cause?.code === 'ECONNREFUSED' ||
-                    err?.cause?.code === 'ENOTFOUND' || err?.cause?.code === 'ETIMEDOUT';
-                if (isConnectionError) {
-                    const apiBase = getApiBaseOverride() || 'https://a.gipity.ai';
-                    console.error(`  ${clrError(`Could not connect to ${apiBase}`)}`);
-                    console.error(`  ${muted('Check your connection and try again.')}`);
-                    process.exit(1);
-                }
-                // Non-connection error (e.g. 401) — fall through to create
-            }
-            const existingSlugs = projects.map(p => p.slug);
-            let project;
-            let isNewProject = false;
-            if (projects.length > 0) {
-                const result = await pickOrCreateProject(projects, existingSlugs);
-                project = result.project;
-                isNewProject = result.isNew;
-            }
-            else if (!fetchFailed) {
-                project = await createNewProject(existingSlugs);
-                isNewProject = true;
-            }
-            else {
-                console.error(`  ${clrError('Could not load projects. Please try again.')}`);
-                process.exit(1);
-            }
-            // Resolve project directory under ~/GipityProjects/{slug}
-            const projectDir = join(PROJECTS_ROOT, project.slug);
-            mkdirSync(projectDir, { recursive: true });
-            process.chdir(projectDir);
-            clearConfigCache();
-            // Fetch agents
-            let agentGuid = '';
-            try {
-                const agents = await get(`/projects/${project.short_guid}/agents`);
-                if (agents.data.length > 0)
-                    agentGuid = agents.data[0].short_guid;
-            }
-            catch {
-                // No agents
-            }
-            const accountSlug = project.user?.account_slug || '';
-            // Always write config (refresh stale GUIDs from a previous setup)
-            saveConfig({
-                projectGuid: project.short_guid,
-                projectSlug: project.slug,
-                accountSlug,
-                agentGuid,
-                conversationGuid: null,
-                apiBase: getApiBaseOverride() || 'https://a.gipity.ai',
-                ignore: ['node_modules', '.git', '.gipity.json', '.gipity/', '.claude/', '.gitignore', 'CLAUDE.md', '*.log'],
-            });
-            console.log(`\n  Using ${projectDir}`);
-            // Sync: push local files up first, then pull any remote-only files down (non-fatal)
-            try {
-                const upResult = await syncUp();
-                if (upResult.pushed > 0) {
-                    console.log(`  Pushed ${upResult.pushed} file${upResult.pushed > 1 ? 's' : ''} to Gipity.`);
-                }
-                const downResult = await syncDown({ confirmDeletions: true });
-                if (downResult.pulled > 0) {
-                    console.log(`  Pulled ${downResult.pulled} file${downResult.pulled > 1 ? 's' : ''} from Gipity.`);
-                }
-            }
-            catch {
-                console.log('  Could not sync files (will retry on next prompt).');
-            }
-            // ── Step 2b: Project type (new projects only) ───────────────────
-            if (isNewProject) {
-                const projectType = await pickProjectType();
-                initialPrompt = projectType.initialPrompt;
-                if (projectType.scaffoldType) {
-                    console.log(`  Scaffolding ${projectType.label}...`);
-                    try {
-                        await post(`/projects/${project.short_guid}/scaffold`, {
-                            title: project.name,
-                            type: projectType.scaffoldType,
-                        });
-                        const scaffoldSync = await syncDown();
-                        if (scaffoldSync.pulled > 0) {
-                            console.log(`  Created ${scaffoldSync.pulled} starter file${scaffoldSync.pulled > 1 ? 's' : ''}.`);
-                        }
-                    }
-                    catch {
-                        console.log('  Scaffolding failed — starting with empty project.');
-                    }
-                }
-            }
-            setupClaudeHooks();
-            setupClaudeMd();
-            setupGitignore();
-            console.log(`  ${success(`Project "${project.name}" ready.`)}\n`);
-        }
-        // ── Step 3: Launch Claude Code ────────────────────────────────────
-        if (opts.claude === false) {
-            console.log(`  Done. cd ${process.cwd()} && claude`);
-            return;
-        }
-        // Check claude is installed
-        try {
-            const checkCmd = process.platform === 'win32' ? 'where claude' : 'which claude';
-            execSync(checkCmd, { stdio: 'ignore' });
-        }
-        catch {
-            console.log('  Claude Code not found. Install it: npm install -g @anthropic-ai/claude-code');
-            console.log(`  Then: cd ${process.cwd()} && claude`);
-            return;
-        }
-        // Pass through all unknown args to claude (everything after 'start-cc')
-        const startCcIdx = process.argv.indexOf('start-cc');
-        const knownFlags = ['--no-claude', '--api-base'];
-        const claudeArgs = process.argv.slice(startCcIdx + 1).filter(arg => {
-            for (const flag of knownFlags) {
-                if (arg === flag)
-                    return false;
-                if (arg.startsWith('--api-base='))
-                    return false;
-            }
-            return true;
-        });
-        // Filter out the value after --api-base if space-separated and after start-cc
-        const apiBaseIdx = process.argv.indexOf('--api-base', startCcIdx);
-        if (apiBaseIdx !== -1) {
-            const valueIdx = claudeArgs.indexOf(process.argv[apiBaseIdx + 1]);
-            if (valueIdx !== -1)
-                claudeArgs.splice(valueIdx, 1);
-        }
-        console.log(`  ${info('Launching Claude Code...')}\n`);
-        const allArgs = initialPrompt
-            ? [initialPrompt, ...claudeArgs]
-            : claudeArgs;
-        // Resolve full path on Windows so we can avoid shell:true, which
-        // passes args through cmd.exe and mangles quotes/special chars.
-        const claudeCmd = resolveCommand('claude');
-        const child = spawn(claudeCmd, allArgs, {
-            stdio: 'inherit',
-            cwd: process.cwd(),
-        });
-        child.on('exit', (code) => process.exit(code ?? 0));
-    }
-    catch (err) {
-        console.error(`\n  ${clrError(`Error: ${err.message}`)}`);
-        process.exit(1);
-    }
-});
-async function pickOrCreateProject(projects, existingSlugs) {
-    const recent = projects.slice(0, 7);
-    const hasMore = projects.length > 7;
-    console.log(`  ${bold('Choose project to open:')}\n`);
-    console.log(`    ${bold('1.')} Create new project`);
-    recent.forEach((p, i) => console.log(`    ${bold(`${i + 2}.`)} ${p.name} ${muted(`(${p.slug})`)}`));
-    if (hasMore)
-        console.log(`    ${bold(`${recent.length + 2}.`)} Show all projects`);
-    console.log('');
-    const maxOption = hasMore ? recent.length + 2 : recent.length + 1;
-    const idx = await pickOne('Choose', maxOption, 1);
-    // Selected a recent project
-    if (idx >= 2 && idx <= recent.length + 1)
-        return { project: recent[idx - 2], isNew: false };
-    // Show all projects
-    if (hasMore && idx === recent.length + 2) {
-        console.log('');
-        console.log(`  ${bold('All projects:')}`);
-        projects.forEach((p, i) => console.log(`    ${bold(`${i + 1}.`)} ${p.name} ${muted(`(${p.slug})`)}`));
-        console.log('');
-        const allChoice = await prompt(`  Choose (1-${projects.length}): `);
-        const allIdx = parseInt(allChoice, 10);
-        if (allIdx >= 1 && allIdx <= projects.length)
-            return { project: projects[allIdx - 1], isNew: false };
-    }
-    // Default (Enter) or 1 = create new project
-    return { project: await createNewProject(existingSlugs), isNew: true };
-}
-async function createNewProject(existingSlugs) {
-    const suggested = suggestProjectName(existingSlugs);
-    console.log('');
-    const name = await prompt(`  ${bold('Project name')} [${bold(suggested)}]: `);
-    const projectName = name || suggested;
-    const projectSlug = slugify(projectName);
-    if (!projectSlug) {
-        console.error(`  ${clrError('Invalid project name.')}`);
-        process.exit(1);
-    }
-    console.log(`  ${info(`Creating "${projectName}"...`)}`);
-    const res = await post('/projects', { name: projectName, slug: projectSlug });
-    console.log(`  ${success('Created.')}`);
-    return res.data;
-}
-const PROJECT_TYPE_OPTIONS = [
-    {
-        label: 'Start empty',
-        initialPrompt: 'This is a new empty project on Gipity. Briefly introduce yourself, mention that I have access to cloud hosting, databases, server-side API endpoints, sandboxed code execution, image generation, speech, and web search, and ask me what I want to build.',
-    },
-    {
-        label: 'Web app',
-        scaffoldType: 'web',
-        initialPrompt: 'This is a new web app project on Gipity. The project has been scaffolded with starter HTML/CSS/JS. Deploy it to dev so I can see it live. Then briefly introduce yourself, mention that I have access to databases, server-side API endpoints, image generation, web search, and cloud hosting, and ask me what I want to build.',
-    },
-    {
-        label: '3D World game',
-        scaffoldType: '3d-world',
-        initialPrompt: 'This is a new 3D World game on Gipity. Deploy it to dev so I can play it right away. Then briefly introduce yourself, mention that I can customize the world, objects, physics, game logic, and multiplayer, and ask me what kind of game I want to make.',
-    },
-];
-async function pickProjectType() {
-    console.log('');
-    console.log(`  ${bold('What kind of project?')}\n`);
-    console.log(`    ${bold('1.')} Start empty. ${muted('Build everything from scratch.')}`);
-    console.log(`    ${bold('2.')} Web app or game. ${muted('Scaffolds basic HTML/CSS/JS starter files.')}`);
-    console.log(`    ${bold('3.')} 3D World game. ${muted('Scaffolds a playable starter world.')}`);
-    console.log('');
-    const idx = await pickOne('Choose', 3, 1);
-    return PROJECT_TYPE_OPTIONS[idx - 1];
-}
-//# sourceMappingURL=start-cc.js.map

package/dist/gip3dw-guide.js

@@ -1,18 +0,0 @@
-/**
- * Shared 3D World template description.
- * Single source of truth used by:
- *   - server/src/services/skills/ (web agent skills)
- *   - cli/src/setup.ts (CLAUDE.md template for Claude Code)
- */
-export const GIP_3DW_GUIDE = `## 3D World
-
-**3D World** is the 3D multiplayer game template on Gipity. All 3D World games share the same visual style, physics engine (Rapier), and multiplayer backend (Colyseus). All files are fully editable.
-
-Scaffold a 3D World project with \`app_scaffold type=3d-world\` (web agent) or \`gipity scaffold --type 3d-world\` (CLI). This creates a playable 3D game with Three.js + Rapier physics + Colyseus multiplayer. Key files: \`config.js\` (metadata), \`settings.js\` (tunable values), \`strings.js\` (display text), \`objects.js\` (entity factories), \`game.js\` (orchestrator), plus engine files (\`core.js\`, \`world.js\`, \`physics.js\`, etc.).
-
-**Genres:** obby/parkour, tycoon, simulator, PvP combat, shooter, tower defense, horror, racing, RPG, social.
-
-**Features:** Opt-in gameplay modules enabled via \`config.features\`. Available: \`rocket-launcher\` (projectile weapon with physics explosions). Example: \`features: { 'rocket-launcher': true }\` in config.js. Features auto-initialize during boot.
-
-Regular game requests ("make a wordle", "build a quiz") should use the standard web scaffold — they don't need the 3D template.`;
-//# sourceMappingURL=gip3dw-guide.js.map