gipity 1.0.389 → 1.0.391

package/dist/commands/claude.js

@@ -21,7 +21,7 @@ import { getAuth, saveAuth, clearAuth } from '../auth.js';
 import { get, post, publicPost, ApiError, getAccountSlug } from '../api.js';
 import { getConfig, saveConfigAt, clearConfigCache, getApiBaseOverride, DEFAULT_API_BASE, getConfigPath } from '../config.js';
 import { sync } from '../sync.js';
-import { slugify, setupClaudeHooks, setupClaudeMd, setupAgentsMd, setupGitignore, DEFAULT_SYNC_IGNORE, isSyncIgnored } from '../setup.js';
+import { slugify, setupClaudeHooks, ensureGipityPluginInstalled, setupClaudeMd, setupAgentsMd, setupGitignore, DEFAULT_SYNC_IGNORE, isSyncIgnored } from '../setup.js';
 import { buildProjectContextBlock as buildProjectContextBlockText, buildNewProjectPrompt, buildResumeWrap, buildFreshWrap, } from '../prompts.js';
 import * as relayState from '../relay/state.js';
 import { maybeOfferRelayOn, ensureDaemonRunning } from '../relay/onboarding.js';
@@ -513,7 +513,9 @@ export const claudeCommand = new Command('claude')
                 // .gipity.json into cwd (no projects-root materialization).
                 const cwdBase = basename(process.cwd());
                 const adoptSlug = slugify(cwdBase) || 'project';
-                const adoptName = cwdBase || adoptSlug;
+                // Server caps name at 100 chars; clamp so a very long dir name
+                // doesn't trip a "Too big" 400 (slugify already clamps the slug).
+                const adoptName = (cwdBase || adoptSlug).slice(0, 100);
                 accountSlug = await getAccountSlug();
                 const adopted = await adoptCurrentDir({
                     cwd: process.cwd(),
@@ -599,6 +601,10 @@ export const claudeCommand = new Command('claude')
             console.log(`  Then: cd ${process.cwd()} && claude`);
             return;
         }
+        // Ensure the Gipity plugin is actually installed at user scope (not just
+        // enabled declaratively) so its capture + file-sync hooks load in this
+        // run's cwd. No-ops once the current version is installed; best-effort.
+        ensureGipityPluginInstalled();
         // Resolve (or create) the backing Gipity conversation for this
         // Claude Code run. The conv_guid is handed to the child (and thus
         // every capture hook spawned by Claude Code) via env var so every

package/dist/commands/init.js

@@ -112,8 +112,9 @@ Working with an existing Gipity project:
                 process.exit(1);
             }
         }
-        // Resolve project name
-        const projectName = name || basename(cwd);
+        // Resolve project name. Server caps name at 100 chars; clamp so a very
+        // long dir name doesn't trip a "Too big" 400 (slugify clamps the slug).
+        const projectName = (name || basename(cwd)).slice(0, 100);
         const projectSlug = slugify(projectName);
         if (!projectSlug) {
             console.error(clrError('Could not derive a valid project slug. Provide a name: gipity init my-app'));

package/dist/commands/status.js

@@ -5,10 +5,14 @@ import { homedir } from 'os';
 import { getAuth, sessionExpired } from '../auth.js';
 import { getConfig, liveUrl } from '../config.js';
 import { brand, success, warning, muted, error as clrError } from '../colors.js';
-import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, setupClaudeHooks, ensureGipityPlugin } from '../setup.js';
-/** Hooks ship in the Gipity Claude Code plugin now - "installed" means the
- *  user-scope settings register the marketplace and enable the plugin.
- *  Claude Code fetches/updates the plugin itself at launch. */
+import { GIPITY_PLUGIN_ID, GIPITY_MARKETPLACE_NAME, setupClaudeHooks, ensureGipityPlugin, ensureGipityPluginInstalled, userScopePluginCurrent } from '../setup.js';
+/** Hooks ship in the Gipity Claude Code plugin now. "Installed" means three
+ *  things must all hold: the user-scope settings register the marketplace and
+ *  enable the plugin (declarative), AND Claude Code actually has a user-scope
+ *  install of the current version on disk. The last check matters because
+ *  CC >=2.1.x does not materialize a user-scope install from enablement alone -
+ *  without it the hooks never load and capture/file-sync silently die, so
+ *  reporting "ok" on the declarative keys alone would be a false green. */
 function checkGipityPlugin() {
     const path = join(homedir(), '.claude', 'settings.json');
     let settings = {};
@@ -23,6 +27,8 @@ function checkGipityPlugin() {
         missing.push('marketplace');
     if (settings?.enabledPlugins?.[GIPITY_PLUGIN_ID] !== true)
         missing.push('plugin');
+    if (!userScopePluginCurrent())
+        missing.push('install');
     return { missing, ok: missing.length === 0 };
 }
 export const statusCommand = new Command('status')
@@ -82,6 +88,9 @@ export const statusCommand = new Command('status')
             // force: an explicit repair request overrides a previous disable.
             ensureGipityPlugin(true);
             setupClaudeHooks();
+            // Re-enabling the declarative keys isn't enough on CC >=2.1.x - also
+            // materialize the user-scope install so the hooks actually load.
+            ensureGipityPluginInstalled();
             console.log(`${muted('Hooks:')}   ${success('repaired - Gipity plugin re-enabled')}`);
         }
         else {

package/dist/setup.js

@@ -4,6 +4,7 @@
 import { resolve, join, dirname } from 'path';
 import { homedir } from 'os';
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { spawnSync } from 'child_process';
 import { SKILLS_CONTENT, BUILD_VS_NON_BUILD_RULE, DEFINITION_OF_DONE } from './knowledge.js';
 export { SKILLS_CONTENT };
 /** Canonical list of workstation artifacts that are NOT part of the project.
@@ -100,13 +101,27 @@ export const PERMISSIONS_SETTINGS = {
 // into each project's .claude/settings.json with absolute paths baked in -
 // that left orphaned entries behind on uninstall (the CLI keeps no inventory
 // of projects it touched) and could even land in the user-global settings
-// when a gipity command ran from $HOME. The plugin replaces all of it with
-// one declarative enablement entry: Claude Code resolves script paths via
-// ${CLAUDE_PLUGIN_ROOT}, fetches the marketplace non-interactively at launch
-// (headless included), and uninstall/disable removes every hook at once.
+// when a gipity command ran from $HOME. The plugin replaces all of it: Claude
+// Code resolves script paths via ${CLAUDE_PLUGIN_ROOT} and uninstall/disable
+// removes every hook at once.
+//
+// Two steps are needed to make it load, split by testability and cost:
+//   - ensureGipityPlugin()          - declarative: register the marketplace +
+//     enable the plugin in ~/.claude/settings.json. Pure file writes.
+//   - ensureGipityPluginInstalled() - imperative: actually install the plugin
+//     at USER scope via the `claude plugin` CLI. Required because CC >=2.1.x no
+//     longer materializes a user-scope install from enablement alone; without
+//     it the hooks load only inside whatever project happened to install the
+//     plugin (often nowhere), silently taking capture + file-sync down.
 export const GIPITY_PLUGIN_ID = 'gipity@gipity';
 export const GIPITY_MARKETPLACE_NAME = 'gipity';
 export const GIPITY_MARKETPLACE_REPO = 'GipityAI/claude-plugin';
+// The plugin version this CLI requires. Bump in lockstep with
+// claude-plugin/.claude-plugin/plugin.json: Claude Code does NOT auto-upgrade
+// an installed plugin when the marketplace advances - only an explicit
+// `plugin install`/`update` does - so this constant is how a CLI upgrade tells
+// ensureGipityPluginInstalled() to refresh a stale user-scope install.
+export const GIPITY_PLUGIN_VERSION = '0.4.0';
 /** True for hook commands the CLI itself wrote into settings.json in past
  *  versions. Matched by signature so migration strips exactly our own
  *  entries and never touches user-authored hooks. */
@@ -192,6 +207,76 @@ export function ensureGipityPlugin(force = false) {
     mkdirSync(claudeDir, { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
 }
+/** Dotted-numeric version compare: true when `have` >= `want` (e.g. "0.4.0"). */
+function versionGte(have, want) {
+    const h = have.split('.').map((n) => parseInt(n, 10) || 0);
+    const w = want.split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(h.length, w.length); i++) {
+        const a = h[i] ?? 0;
+        const b = w[i] ?? 0;
+        if (a !== b)
+            return a > b;
+    }
+    return true;
+}
+/** True when Claude Code already records a USER-scope install of the Gipity
+ *  plugin at >= the version this CLI needs - the common case, letting the
+ *  caller skip the (slow) reinstall. Reads installed_plugins.json directly so
+ *  the check costs no subprocess. Exported so `gipity status` can tell an
+ *  actually-loaded plugin apart from one that's merely enabled-but-uninstalled
+ *  (which would otherwise read as a false-green "hooks enabled"). */
+export function userScopePluginCurrent() {
+    try {
+        const p = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+        const data = JSON.parse(readFileSync(p, 'utf-8'));
+        const entries = data?.plugins?.[GIPITY_PLUGIN_ID];
+        if (!Array.isArray(entries))
+            return false;
+        return entries.some((e) => e?.scope === 'user' &&
+            typeof e?.version === 'string' &&
+            versionGte(e.version, GIPITY_PLUGIN_VERSION));
+    }
+    catch {
+        return false;
+    }
+}
+function claudeOnPath() {
+    const probe = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['claude'], {
+        encoding: 'utf-8',
+    });
+    return probe.status === 0 && !!probe.stdout?.trim();
+}
+/** Materialize the Gipity plugin at USER scope via Claude Code's own plugin
+ *  CLI, so its hooks (session capture + file sync) load in EVERY directory.
+ *
+ *  ensureGipityPlugin() only writes the declarative `enabledPlugins` /
+ *  `extraKnownMarketplaces` keys. That was enough on older Claude Code, but
+ *  CC >=2.1.x no longer materializes a user-scope install from an enablement
+ *  entry alone: without an actual user-scope install the plugin loads only in
+ *  whatever project happened to install it (often nowhere), so capture and
+ *  file-sync silently go dark everywhere else. We drive the supported
+ *  `claude plugin` commands rather than trust implicit resolution.
+ *
+ *  Best-effort and non-fatal - a missing `claude` or a failed install must
+ *  never break `gipity claude`. Skips entirely when the user-scope install is
+ *  already current, so it shells out at most once per plugin-version bump. */
+export function ensureGipityPluginInstalled() {
+    if (userScopePluginCurrent())
+        return;
+    if (!claudeOnPath())
+        return;
+    // Refresh the marketplace clone so `install` resolves the current version,
+    // then (re)install at user scope - idempotent, and upgrades an older or
+    // project-scoped install to the current one at user scope.
+    spawnSync('claude', ['plugin', 'marketplace', 'update', GIPITY_MARKETPLACE_NAME], {
+        stdio: 'ignore',
+        timeout: 120_000,
+    });
+    spawnSync('claude', ['plugin', 'install', GIPITY_PLUGIN_ID, '--scope', 'user'], {
+        stdio: 'ignore',
+        timeout: 120_000,
+    });
+}
 export function setupClaudeHooks() {
     // All hooks ship in the plugin - enable it at user scope (and clean up any
     // legacy hook blocks in the user-global settings while we're there).
@@ -404,11 +489,23 @@ export function setupGitignore() {
         writeFileSync(gitignorePath, entries.join('\n') + '\n');
     }
 }
+/** The server caps slugs at 50 (MAX_PROJECT_SLUG_LENGTH); we cap shorter for
+ *  readability, since the slug is also the on-disk folder and the URL path
+ *  segment. Keeps long-named directories from producing valid-but-ugly slugs. */
+export const MAX_SLUG_LENGTH = 40;
 export function slugify(name) {
-    return name
+    const slug = name
         .toLowerCase()
         .replace(/[^a-z0-9-]/g, '-')
         .replace(/-+/g, '-')
         .replace(/^-|-$/g, '');
+    if (slug.length <= MAX_SLUG_LENGTH)
+        return slug;
+    // Cut at the last word (hyphen) boundary within the cap so we don't slice
+    // mid-word (e.g. "...call-no"). Fall back to a hard cut if the first word
+    // alone already exceeds the cap.
+    const cut = slug.slice(0, MAX_SLUG_LENGTH);
+    const lastHyphen = cut.lastIndexOf('-');
+    return (lastHyphen > 0 ? cut.slice(0, lastHyphen) : cut).replace(/-+$/, '');
 }
 //# sourceMappingURL=setup.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gipity",
-  "version": "1.0.389",
+  "version": "1.0.391",
   "description": "The full-stack platform tuned for AI agents. Database, storage, auth, functions, deploy, and drop-in kits - all agent-tuned. Pair with Claude Code or use standalone.",
   "bin": {
     "gipity": "dist/updater/shim.js",