gipity 1.0.407 → 1.0.409

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

package/dist/platform-overview.js

@@ -1,52 +0,0 @@
-/**
- * Shared Gipity platform capability descriptions.
- * Single source of truth used by:
- *   - server/src/services/skills/ (web agent skills)
- *   - tools/gipity-cli/src/setup.ts (CLAUDE.md template for Claude Code)
- */
-export const PLATFORM_SERVICES = `## Platform Services
-
-Capabilities beyond local file editing — use \`gipity chat\` (CLI) or the built-in tools (web agent):
-
-- **Image generation**: OpenAI (gpt-image-1, DALL-E 3) and BFL/Flux
-- **Speech / TTS**: ElevenLabs and OpenAI voices (streaming and batch)
-- **Sound effects / Music**: ElevenLabs audio generation
-- **Audio processing**: Transcription, source isolation
-- **Web search**: Brave API
-- **Twitter/X search**: v2 API, last 7 days
-- **Browser automation**: Open URLs, screenshot, click, fill forms, read console
-- **Workflow automation**: Cron-scheduled or webhook-triggered multi-step AI pipelines
-- **Email**: SendGrid transactional email
-- **Google services**: Gmail, Google Calendar integration
-- **External services**: Slack, GitHub, Todoist, Notion via service connectors
-- **Cross-model queries**: Ask GPT-5, Claude, etc. for second opinions
-- **Serverless functions**: JavaScript functions callable via REST`;
-export const CLI_COMMANDS = `## CLI Commands
-
-| Command | Purpose |
-|---------|---------|
-| \`gipity scaffold [title]\` | Create app structure (\`--type web\` default, or \`--type 3d-world\` for 3D games) |
-| \`gipity deploy [dev\\|prod]\` | Deploy and get live URL |
-| \`gipity sync [up\\|down\\|check]\` | Manual file sync |
-| \`gipity db create <name>\` | Create a project database |
-| \`gipity db query "SQL"\` | Run SQL on project database |
-| \`gipity db list\` | List databases |
-| \`gipity memory list\\|read\\|write\` | Persistent key-value memory |
-| \`gipity api list\\|define\\|get\` | Manage backend API procedures |
-| \`gipity checkpoint list\` | List file snapshots |
-| \`gipity checkpoint restore <id>\` | Restore files to a snapshot (undo) |
-| \`gipity logs fn <name>\` | View function execution logs (errors, timing) |
-| \`gipity browser <url>\` | Inspect a URL: console errors, timing, failed resources |
-| \`gipity status\` | Check project and sync status |
-
-All commands support \`--json\` for structured output.`;
-export const DEPLOY_VERIFICATION = `## Deploy Verification
-
-Use the browser tool to verify deploys when it matters — first deploy, structural changes (new pages, new frameworks, changed imports), or when something might have broken. Skip verification for trivial changes (copy tweaks, style adjustments, config values).
-
-To verify: \`browser action=open url=<deployed-url>\` — waits for async modules, captures console errors automatically. Check output for \`[Console errors captured after page load]\`. Use \`browser action=screenshot\` to confirm visual correctness.
-
-**Debugging in production:** Add \`console.error()\` calls to app code for diagnostics, redeploy, then use \`browser action=console\` to read the output. Remove debug logging when done.
-
-**Screenshots via \`gipity chat\`**: For 3D games and pages with async rendering (WebGL, canvas, dynamic content), tell the agent to wait a few seconds after opening before capturing so the scene renders. The saved filename may differ from what you requested (collision-free naming). Always check the tool output for the actual saved path.`;
-//# sourceMappingURL=platform-overview.js.map

package/dist/relay/transcripts.js

@@ -1,119 +0,0 @@
-/**
- * Shared helpers for reading Claude Code's JSONL transcript and mapping its
- * entries into our `/ingest` wire format. Used by:
- *
- *   - `hook-capture.ts`  (Stop hook) — streams deltas live while Claude runs
- *   - `daemon.ts`        (post-spawn sweep) — catches anything the hook dropped
- *
- * Both paths share one offset file at `.gipity/transcripts/<session_id>.offset`
- * so whichever path posts first owns the delta; the other sees an empty read
- * and no-ops. Ordering is guaranteed: hooks run inside the `gipity claude`
- * child process, the sweep runs after that child has exited.
- */
-import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
-import { resolve, join, dirname } from 'path';
-import { homedir } from 'os';
-// ─── offset file (shared lock-step between hook and sweep) ─────────────
-export function offsetPath(sessionId) {
-    return resolve(process.cwd(), '.gipity', 'transcripts', `${sessionId}.offset`);
-}
-export function readOffset(sessionId) {
-    try {
-        return parseInt(readFileSync(offsetPath(sessionId), 'utf-8'), 10) || 0;
-    }
-    catch {
-        return 0;
-    }
-}
-export function writeOffset(sessionId, offset) {
-    const p = offsetPath(sessionId);
-    mkdirSync(dirname(p), { recursive: true });
-    writeFileSync(p, String(offset));
-}
-export function latestSessionPath(convGuid) {
-    return resolve(process.cwd(), '.gipity', 'transcripts', `latest-${convGuid}.json`);
-}
-export function writeLatestSession(cwd, convGuid, rec) {
-    const p = join(cwd, '.gipity', 'transcripts', `latest-${convGuid}.json`);
-    mkdirSync(dirname(p), { recursive: true });
-    writeFileSync(p, JSON.stringify(rec, null, 2));
-}
-export function readLatestSession(cwd, convGuid) {
-    try {
-        const p = join(cwd, '.gipity', 'transcripts', `latest-${convGuid}.json`);
-        if (!existsSync(p))
-            return null;
-        const parsed = JSON.parse(readFileSync(p, 'utf-8'));
-        if (typeof parsed?.session_id !== 'string')
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-// ─── delta reader ──────────────────────────────────────────────────────
-/** Parse JSONL delta from `transcriptPath` starting at the stored offset
- *  for `sessionId`. The caller advances the offset (via `writeOffset`)
- *  ONLY after the ingest POST succeeds — a failed POST leaves the offset
- *  behind so the next reader picks up the same delta. */
-export 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; // file regressed (rotated/truncated) — 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 };
-}
-// ─── JSONL → ingest mapping ────────────────────────────────────────────
-/** Pull plain text out of an assistant entry's `message.content` array. */
-function joinAssistantText(entry) {
-    const content = entry?.message?.content;
-    if (!Array.isArray(content))
-        return { text: '', blocks: null };
-    const parts = [];
-    for (const block of content) {
-        if (block?.type === 'text' && typeof block.text === 'string')
-            parts.push(block.text);
-    }
-    return { text: parts.join('\n'), blocks: content };
-}
-/** Convert Claude's raw JSONL entries into our ingest format. We only
- *  emit `assistant` entries here — user prompts and tool calls come in via
- *  dedicated hooks (UserPromptSubmit, PostToolUse), so pulling them from
- *  the transcript would duplicate. If those hooks fail we accept partial
- *  recovery (the assistant turn is the main thing the user sees). */
-export function mapEntriesToIngest(entries) {
-    const out = [];
-    for (const entry of entries) {
-        if (entry?.type !== 'assistant')
-            continue;
-        const { text, blocks } = joinAssistantText(entry);
-        if (!text && (!blocks || blocks.length === 0))
-            continue;
-        out.push({ kind: 'assistant', text, blocks: blocks ?? [] });
-    }
-    return out;
-}
-// ─── transcript path resolver (mirror of daemon.ts's helper) ───────────
-// Claude Code encodes the project cwd into a slug by replacing `/` with
-// `-`. Kept in sync with daemon's `transcriptPathFor` — both callers
-// import from here once daemon.ts is refactored.
-export function transcriptPathFor(cwd, sessionId) {
-    const slug = cwd.replace(/\//g, '-');
-    return join(homedir(), '.claude', 'projects', slug, `${sessionId}.jsonl`);
-}
-//# sourceMappingURL=transcripts.js.map

package/hooks/post-write.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-# PostToolUse hook: push file to Gipity after Write/Edit
-# Runs after CC's Write or Edit tool. Fires gipity push in background.
-
-INPUT=$(cat)
-FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
-
-# Skip if no file path extracted
-[ -z "$FILE_PATH" ] && exit 0
-
-# Skip if not a Gipity project
-[ ! -f ".gipity.json" ] && exit 0
-
-# Push in background, suppress output
-gipity push "$FILE_PATH" --quiet &
-disown
-exit 0

package/hooks/pre-turn.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-# UserPromptSubmit hook: sync check before each CC turn
-# Pulls remote changes and reports diff as systemMessage.
-
-# Skip if not a Gipity project
-[ ! -f ".gipity.json" ] && exit 0
-
-# Sync down with JSON output
-RESULT=$(gipity sync down --json 2>/dev/null)
-
-# Check if any files were pulled
-PULLED=$(echo "$RESULT" | jq -r '.pulled // 0' 2>/dev/null)
-
-if [ "$PULLED" -gt 0 ]; then
-  SUMMARY=$(echo "$RESULT" | jq -r '.summary // "Files changed remotely."' 2>/dev/null)
-  # Output systemMessage so CC sees the diff
-  echo "{\"systemMessage\": \"Gipity sync: ${SUMMARY}\"}"
-fi
-
-exit 0