@aexol/opencode-wizard 0.3.2 → 0.3.3

package/README.md

@@ -52,6 +52,10 @@ Call `opencode_wizard_published_skills_fetch` without `skill` or `skills` to man
 
 No-arg discovery returns published skill summaries, assignment counts split into `global`, `project`, `user`, and `other`, policy metadata, and no markdown bodies. Existing `skill` and `skills` calls still fetch one or more full skill body/detail payloads by slug, artifact name, or skill name.
 
+Workspace delivery still follows the backend contract: the plugin sends `workspaceSlug` when it has one, otherwise falls back to `repositoryUrl`. The plugin now prefers configured or learned workspace slug mappings over a repo-basename fallback, and learns durable slug-to-repo mappings from successful backend catalog responses so worktrees and nontrivial repo roots stay aligned.
+
+Published skill fetches still support `refresh: true`, but normal cache entries now self-expire after 30 seconds and fetch/status payloads surface `source`, `workspaceSlug`, and `workspaceSlugSource` so stale-vs-refreshed behavior is visible without relying on manual cache deletion.
+
 Use `opencode_wizard_published_skill_preference_set` for non-TUI preference actions (`install`, `uninstall`, `ignore`, `unignore`) against the same server-backed preference API used by the TUI overlay.
 
 `GLOBAL_CONTEXT` skills are active context skills and are not meant to be installed per project. `PROJECT_INSTALLABLE` skills are gallery/installable skills that may be attached globally or to a workspace/path through assignment records; those assignments remain the source of truth for what is active in a catalog response.

package/dist/server.d.ts

@@ -5,6 +5,7 @@ type ResolvedConfig = {
     authSessionUrl: string;
     presenceUrl: string;
     actionsUrl: string;
+    configuredWorkspaceSlug: string | null;
     fallbackWorkspaceSlug: string;
     rootSkillSeedPath: string;
     authStatePath: string;
@@ -13,6 +14,8 @@ type WorkspaceResolution = {
     requestedDirectory: string;
     repositoryRoot: string;
     repositoryUrl: string | null;
+    workspaceSlug?: string | null;
+    workspaceSlugSource?: 'configured' | 'learned' | 'backend' | 'fallback' | 'repositoryUrl' | 'placeholder';
     fallbackWorkspaceSlug: string | null;
     directoryPath: string;
     cacheKey: string;
@@ -271,6 +274,8 @@ declare const toWorkspaceResolutionOutput: (resolution: WorkspaceResolution) =>
     requestedDirectory: string;
     repositoryRoot: string;
     repositoryUrl: string | null;
+    workspaceSlug: string | null | undefined;
+    workspaceSlugSource: "configured" | "learned" | "backend" | "fallback" | "repositoryUrl" | "placeholder" | undefined;
     fallbackWorkspaceSlug: string | null;
     directoryPath: string;
 };

package/dist/server.js

@@ -14,6 +14,7 @@ const MODULE_FILE_PATH = fileURLToPath(import.meta.url);
 const PACKAGE_ROOT_PATH = path.resolve(path.dirname(MODULE_FILE_PATH), '..');
 export const PLUGIN_ID = 'opencode-wizard';
 const CACHE_TTL_MS = 30_000;
+const WORKSPACE_MAPPING_LIMIT = 100;
 const ROOT_SKILL_SEED_PATH = '.opencode/skills';
 const GLOBAL_CONFIG_PATH = path.join(os.homedir(), '.config', 'opencode', 'opencode-wizard.json');
 const LEGACY_AUTH_STATE_PATH = 'plugin/opencode-wizard/.generated/auth-state.json';
@@ -330,14 +331,19 @@ const resolveBackendOrigin = async worktree => {
     localBackendOrigin: envValues.get('OPENCODE_WIZARD_BACKEND_ORIGIN')
   });
 };
+const readConfiguredWorkspaceSlug = () => {
+  const configuredWorkspaceSlug = process.env.OPENCODE_WIZARD_SKILLS_WORKSPACE_SLUG?.trim();
+  if (!configuredWorkspaceSlug) return null;
+  return toWorkspaceSlug(configuredWorkspaceSlug);
+};
 const toWorkspaceSlug = value => {
   const normalized = value.trim().toLowerCase().replace(/[^a-z0-9-]+/gu, '-').replace(/^-+|-+$/gu, '');
   if (normalized) return normalized;
   return 'workspace';
 };
 const resolveFallbackWorkspaceSlug = worktree => {
-  const configuredWorkspaceSlug = process.env.OPENCODE_WIZARD_SKILLS_WORKSPACE_SLUG?.trim();
-  if (configuredWorkspaceSlug) return toWorkspaceSlug(configuredWorkspaceSlug);
+  const configuredWorkspaceSlug = readConfiguredWorkspaceSlug();
+  if (configuredWorkspaceSlug) return configuredWorkspaceSlug;
   return toWorkspaceSlug(path.basename(path.resolve(worktree)));
 };
 export const resolveConfig = async worktree => {
@@ -348,6 +354,7 @@ export const resolveConfig = async worktree => {
     authSessionUrl: `${backendOrigin}/api/opencode-plugin/oauth/session`,
     presenceUrl: `${backendOrigin}/api/opencode-plugin/presence`,
     actionsUrl: `${backendOrigin}/api/opencode-plugin/actions`,
+    configuredWorkspaceSlug: readConfiguredWorkspaceSlug(),
     fallbackWorkspaceSlug: resolveFallbackWorkspaceSlug(worktree),
     rootSkillSeedPath: ROOT_SKILL_SEED_PATH,
     authStatePath: GLOBAL_CONFIG_PATH
@@ -408,22 +415,31 @@ const resolveWorkspace = async ({
   const gitRoot = await resolveGitRoot(requestedDirectory);
   const repositoryRoot = gitRoot ?? requestedDirectory;
   const repositoryUrl = gitRoot ? await resolveGitRemoteOriginUrl(gitRoot) : null;
+  const learnedWorkspaceMapping = await findWorkspaceSlugMapping({
+    configFile: config.authStatePath,
+    repositoryUrl,
+    repositoryRoot
+  });
   const fallbackWorkspaceSlug = config.fallbackWorkspaceSlug;
   const directoryPath = normalizeRepositoryPath(repositoryRoot, requestedDirectory);
-  const workspaceIdentity = `workspaceSlug:${fallbackWorkspaceSlug}`;
+  const workspaceSlug = config.configuredWorkspaceSlug ?? learnedWorkspaceMapping?.workspaceSlug ?? fallbackWorkspaceSlug ?? null;
+  const workspaceSlugSource = config.configuredWorkspaceSlug ? 'configured' : learnedWorkspaceMapping?.workspaceSlug ? 'learned' : fallbackWorkspaceSlug ? 'fallback' : repositoryUrl ? 'repositoryUrl' : 'placeholder';
+  const workspaceIdentity = workspaceSlug ? `workspaceSlug:${workspaceSlug}` : repositoryUrl ? `repository:${repositoryUrl}` : 'workspace:placeholder';
   return {
     requestedDirectory,
     repositoryRoot,
     repositoryUrl,
+    workspaceSlug,
+    workspaceSlugSource,
     fallbackWorkspaceSlug,
     directoryPath,
     cacheKey: JSON.stringify([workspaceIdentity, directoryPath])
   };
 };
 const toDeliveryInput = resolution => {
-  if (resolution.fallbackWorkspaceSlug) {
+  if (resolution.workspaceSlug) {
     return {
-      workspaceSlug: resolution.fallbackWorkspaceSlug,
+      workspaceSlug: resolution.workspaceSlug,
       directoryPath: resolution.directoryPath
     };
   }
@@ -475,6 +491,76 @@ const withoutLegacyPublishedSkillPreferences = config => {
 const hasLegacyPublishedSkillPreferences = config => {
   return Object.prototype.hasOwnProperty.call(config, 'publishedSkillPreferences') || Object.prototype.hasOwnProperty.call(config, 'ignoredPublishedSkills');
 };
+const isStoredWorkspaceSlugMapping = value => {
+  if (!isRecord(value)) return false;
+  const {
+    repositoryUrl,
+    repositoryRoot,
+    workspaceSlug,
+    updatedAt
+  } = value;
+  const hasValidRepositoryUrl = repositoryUrl === null || typeof repositoryUrl === 'string';
+  const hasValidRepositoryRoot = repositoryRoot === null || typeof repositoryRoot === 'string';
+  return hasValidRepositoryUrl && hasValidRepositoryRoot && typeof workspaceSlug === 'string' && workspaceSlug.trim().length > 0 && isValidIsoDateString(updatedAt);
+};
+const readWorkspaceSlugMappings = async configFile => {
+  const storedConfig = await readGlobalConfig(configFile);
+  const mappings = storedConfig.workspaceSlugMappings;
+  if (!Array.isArray(mappings)) return [];
+  return mappings.filter(isStoredWorkspaceSlugMapping).slice(0, WORKSPACE_MAPPING_LIMIT);
+};
+const writeWorkspaceSlugMappings = async (configFile, nextMappings) => {
+  const storedConfig = await readGlobalConfig(configFile);
+  await writeGlobalConfig(configFile, {
+    ...withoutLegacyPublishedSkillPreferences(storedConfig),
+    workspaceSlugMappings: nextMappings.slice(0, WORKSPACE_MAPPING_LIMIT)
+  });
+};
+const normalizeStoredRepositoryRoot = value => {
+  if (!value) return null;
+  return normalizeAbsolutePath(value);
+};
+const upsertWorkspaceSlugMapping = async ({
+  configFile,
+  repositoryUrl,
+  repositoryRoot,
+  workspaceSlug
+}) => {
+  const normalizedWorkspaceSlug = toWorkspaceSlug(workspaceSlug);
+  if (!normalizedWorkspaceSlug) return;
+  const normalizedRepositoryRoot = normalizeStoredRepositoryRoot(repositoryRoot);
+  const existingMappings = await readWorkspaceSlugMappings(configFile);
+  const filteredMappings = existingMappings.filter(mapping => {
+    if (repositoryUrl && mapping.repositoryUrl === repositoryUrl) return false;
+    if (normalizedRepositoryRoot && normalizeStoredRepositoryRoot(mapping.repositoryRoot) === normalizedRepositoryRoot) {
+      return false;
+    }
+    return true;
+  });
+  await writeWorkspaceSlugMappings(configFile, [{
+    repositoryUrl,
+    repositoryRoot: normalizedRepositoryRoot,
+    workspaceSlug: normalizedWorkspaceSlug,
+    updatedAt: new Date().toISOString()
+  }, ...filteredMappings]);
+};
+const findWorkspaceSlugMapping = async ({
+  configFile,
+  repositoryUrl,
+  repositoryRoot
+}) => {
+  const normalizedRepositoryRoot = normalizeStoredRepositoryRoot(repositoryRoot);
+  const mappings = await readWorkspaceSlugMappings(configFile);
+  if (repositoryUrl) {
+    const repositoryMatch = mappings.find(mapping => mapping.repositoryUrl === repositoryUrl);
+    if (repositoryMatch) return repositoryMatch;
+  }
+  if (normalizedRepositoryRoot) {
+    const rootMatch = mappings.find(mapping => normalizeStoredRepositoryRoot(mapping.repositoryRoot) === normalizedRepositoryRoot);
+    if (rootMatch) return rootMatch;
+  }
+  return null;
+};
 const readGlobalAuthState = async configFile => {
   const storedConfig = await readGlobalConfig(configFile);
   const storedAuthState = storedConfig.auth;
@@ -531,7 +617,7 @@ const toPublishedSkillPreferenceScope = (value, defaultScope) => {
   throw new Error('Published skill preferenceScope must be either global or project.');
 };
 const getPublishedSkillIgnoreScopeKey = (resolution, payload) => {
-  const workspaceSlug = payload?.workspace?.slug ?? resolution.fallbackWorkspaceSlug;
+  const workspaceSlug = payload?.workspace?.slug ?? resolution.workspaceSlug ?? resolution.fallbackWorkspaceSlug;
   if (workspaceSlug) return `workspace:${toWorkspaceSlug(workspaceSlug)}`;
   if (resolution.repositoryUrl) return `repository:${resolution.repositoryUrl}`;
   return `path:${toWorkspaceSlug(path.basename(resolution.repositoryRoot))}`;
@@ -879,6 +965,8 @@ const toWorkspaceResolutionOutput = resolution => ({
   requestedDirectory: resolution.requestedDirectory,
   repositoryRoot: resolution.repositoryRoot,
   repositoryUrl: resolution.repositoryUrl,
+  workspaceSlug: resolution.workspaceSlug,
+  workspaceSlugSource: resolution.workspaceSlugSource,
   fallbackWorkspaceSlug: resolution.fallbackWorkspaceSlug,
   directoryPath: resolution.directoryPath
 });
@@ -886,6 +974,8 @@ const toWorkspaceResolutionMetadata = resolution => ({
   directoryPath: resolution.directoryPath,
   repositoryRoot: resolution.repositoryRoot,
   repositoryUrl: resolution.repositoryUrl ?? '',
+  workspaceSlug: resolution.workspaceSlug ?? '',
+  workspaceSlugSource: resolution.workspaceSlugSource ?? 'placeholder',
   fallbackWorkspaceSlug: resolution.fallbackWorkspaceSlug ?? ''
 });
 const formatStatusOutput = async (worktree, config, publishedSkillsResult, loginBootstrapSnapshot) => {
@@ -1183,7 +1273,12 @@ const toPluginStatusMetadata = snapshot => ({
   pluginStatus: snapshot.status,
   authStatus: snapshot.authState.status,
   authEmail: snapshot.authState.email ?? '',
-  authUserId: snapshot.authState.userId ?? ''
+  authUserId: snapshot.authState.userId ?? '',
+  directoryPath: snapshot.workspaceResolution.directoryPath,
+  repositoryUrl: snapshot.workspaceResolution.repositoryUrl ?? '',
+  source: snapshot.source,
+  workspaceSlug: snapshot.workspaceResolution.workspaceSlug ?? '',
+  workspaceSlugSource: snapshot.workspaceResolution.workspaceSlugSource ?? 'placeholder'
 });
 const isUnauthorizedGraphQlMessage = message => {
   const normalizedMessage = message.toLowerCase();
@@ -1504,6 +1599,24 @@ const fetchPublishedSkillsCatalog = async (worktree, config, resolution, signal,
     source: 'network'
   };
 };
+const maybePersistWorkspaceSlugFromCatalog = async ({
+  config,
+  resolution,
+  fetchResult
+}) => {
+  if (!fetchResult.ok) return;
+  const backendWorkspaceSlug = fetchResult.payload.workspace?.slug?.trim();
+  if (!backendWorkspaceSlug) return;
+  const normalizedWorkspaceSlug = toWorkspaceSlug(backendWorkspaceSlug);
+  if (!normalizedWorkspaceSlug) return;
+  if (resolution.workspaceSlug === normalizedWorkspaceSlug && resolution.workspaceSlugSource !== 'fallback') return;
+  await upsertWorkspaceSlugMapping({
+    configFile: config.authStatePath,
+    repositoryUrl: resolution.repositoryUrl,
+    repositoryRoot: resolution.repositoryRoot,
+    workspaceSlug: normalizedWorkspaceSlug
+  });
+};
 const fetchPublishedSkillDetail = async ({
   worktree,
   config,
@@ -1941,6 +2054,11 @@ const OpencodeWizardSkillsPlugin = async input => {
     }
     const requestPromise = (async () => {
       const fetchResult = await fetchPublishedSkillsCatalog(input.worktree, config, workspaceResolution, signal, clearPublishedSkillState);
+      await maybePersistWorkspaceSlugFromCatalog({
+        config,
+        resolution: workspaceResolution,
+        fetchResult
+      });
       cache.set(cacheKey, {
         result: fetchResult,
         expiresAt: Date.now() + CACHE_TTL_MS
@@ -1971,7 +2089,7 @@ const OpencodeWizardSkillsPlugin = async input => {
     const cacheKey = getDetailCacheKey(catalogCacheKey, item.skillVersion.id);
     const inflightKey = getDetailInflightKey(catalogCacheKey, item.skillVersion.id, purpose);
     const cached = detailCache.get(cacheKey);
-    if (purpose === 'SYSTEM_CONTEXT' && useCache && cached && cached.expiresAt > Date.now()) {
+    if (useCache && cached && cached.expiresAt > Date.now()) {
       return {
         ok: true,
         detail: toPublishedSkillDetail({
@@ -2148,11 +2266,13 @@ const OpencodeWizardSkillsPlugin = async input => {
           },
           fetchedAt: filteredPublishedSkillsResult.fetchResult.fetchedAt,
           source: filteredPublishedSkillsResult.fetchResult.source,
-          message: 'Catalog discovery only. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.'
+          cacheTtlMs: CACHE_TTL_MS,
+          message: args.refresh ? 'Catalog discovery refreshed from the backend. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.' : 'Catalog discovery only. Cached results expire automatically after 30 seconds, or pass `refresh: true` to force a backend refresh immediately. Provide `skill` for one identifier or prefer `skills` for comma/newline-separated multiple identifiers to fetch markdown bodies/details.'
         }, null, 2),
         metadata: {
           status: 'ready',
           ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          source: filteredPublishedSkillsResult.fetchResult.source,
           publishedSkillCount: catalog.publishedSkillCount.toString(),
           globalAssignmentCount: catalog.assignmentCounts.global.toString(),
           projectAssignmentCount: catalog.assignmentCounts.project.toString(),
@@ -2242,6 +2362,7 @@ const OpencodeWizardSkillsPlugin = async input => {
         metadata: {
           status: 'ready',
           ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+          source: filteredPublishedSkillsResult.fetchResult.source,
           skillSlug: detail.skillSlug
         }
       };
@@ -2271,6 +2392,7 @@ const OpencodeWizardSkillsPlugin = async input => {
       metadata: {
         status: selection.missingIdentifiers.length > 0 ? 'partial' : 'ready',
         ...toWorkspaceResolutionMetadata(filteredPublishedSkillsResult.workspaceResolution),
+        source: filteredPublishedSkillsResult.fetchResult.source,
         matchedCount: skillDetails.length.toString()
       }
     };