Files
Netcatty/infrastructure/ai/quickMessages.ts
T
8b5b0c4416 fix(ai): keep dropped AI chats recoverable with dangling marking + /rebind; reuse workspace id on merge (#4019)
* fix(ai): keep dropped AI chats recoverable with dangling marking and /rebind

Closing a member terminal or dissolving a workspace used to clear the
chat's active pointer, making it invisible (scope rank 0) and
unrecoverable from the UI even though the record survived in storage.

- orphan cleanup now marks dropped chats `scopeDangling: true` and keeps
  record + active pointer intact; the flag clears when the target
  returns or the chat is rebound
- `/chats` lists dangling chats with a numbered inline affordance and
  hint line
- new `/rebind <n>` panel action rewrites `scope` to the panel's current
  scope, clears the marker and restores the active pointer
- i18n keys added for en / zh-CN / zh-TW / es / ru

Stacked on #4018. Refs #4015 (R2).

* fix(workspace): reuse existing workspace id when merging tabs with a workspace

createWorkspaceFromSessions silently no-opped when either merged tab
already belonged to a workspace (e.g. dragging a workspace pane onto a
standalone terminal), and the older dissolve->recreate behavior
regenerated the id that workspace-scoped AI chats bind to.

When one of the merged tabs has a workspace, the orphan tab now joins
that existing workspace (pane inserted next to the anchor session, tab
slot collapsed), so workspace-scoped chat bindings survive. Merging two
standalone tabs still creates a fresh workspace.

Stacked on #4018. Refs #4015 (R3).

* fix(ai): persist cleaned active map on dangling chat rebind

rebindSessionScope was updating React state to drop stale old-scope
pointers, then rebuilding localStorage from the pre-rebind snapshot and
resurrecting them. Persist the same cleaned map via rebindActiveSessionMap.

* fix(ai): persist rebind map inside setState; wire backup actions on terminal panel

- Write cleaned active-session map from inside the rebind updater so a
  deferred React setState cannot skip snapshot/localStorage persistence.
- Pass exportSessionsBackup/importSessionsBackup through TerminalLayerSupport
  and include them in AI_CHAT_SIDE_PANEL_AI_STATE_KEYS so history-drawer
  backup buttons work on the normal terminal path.

* fix(ai): guard backup restore races and use app-wide live targets for /chats

- Skip restore when in-memory sessions already exist; apply snapshot,
  storage write, and AI state emit atomically inside the empty-state path
  so peer useAIState instances see the restore.
- Thread validAIScopeTargetIds into AIChatSidePanel as liveScopeTargetIds
  so /chats does not mark chats bound to other open terminals as dangling.

* fix(ai): open rebound chat in panel view and refresh /chats listing

- rebindSessionScope also sets the panel view to the rebound session so an
  existing draft/other chat does not keep hiding the recovery.
- After /rebind, rewrite the stored listing instead of rebuilding from the
  stale render so the chat is no longer offered as dangling.

* fix(workspace): invert join split when dragged pane owns workspace; refresh /chats titles

- When merging a workspace-owned dragged pane onto a standalone tab, the
  orphan is inserted — invert the drop position so the previewed side matches.
- Compare workspaces in AIChatSidePanel memo so /chats picks up renames.

* fix(ai): validate live sessions array on boot; mark imported orphans dangling

- Reject parseable non-array store values (e.g. {}) via readLiveSessionsArray
  so boot restore is not blocked by a corrupt-but-truthy value.
- After manual import, re-run orphan cleanup with the last known live target
  set so chats bound to closed scopes become dangling and /rebind-able.

* fix(ai): merge imported sessions before orphan cleanup

Apply import merge to the snapshot/ref synchronously, then run dangling
marking, so a deferred setState cannot let cleanup rewrite over the import.

* fix(ai): mark restored/imported orphans dangling even with no live targets

Restore and import do not change live terminals/workspaces, so the orphan
cleanup effect will not re-run. Always call cleanup against the last known
live target set after those paths — an empty set is a valid observed state
(nothing mounted), not an unavailable snapshot — so chats bound to missing
scopes become dangling and /chats can offer /rebind.

* fix(ai): apply backup restore synchronously before dangling cleanup

Do not gate restore + orphan marking on a setState updater having run.
A deferred updater left didRestore false, skipped cleanup, and could leave
restored chats with missing scopes unmarked and unrebindable from /chats.

* fix(ai): complete /rebind from a partial slash picker selection

Selecting Rebind after typing `/re` left the composer unchanged, so a
following number became `/re 1` and could be sent to the agent. Replace the
slash query with `/rebind ` the same way Rename does.

* fix(ai): replace hostIds on rebind; skip non-array backup generations

- Rebind builds a fresh destination scope (including hostIds from the
  panel) instead of spreading the old scope, so history matching follows
  the new terminal/workspace host.
- readLatestGeneration treats valid JSON that is not a session array as
  unusable and continues to older generations, matching corrupt skips.

* fix(ai): revalidate dangling chat before /rebind from stale /chats listing

Skip rebind when the cached entry is deleted or already bound to a live
scope; drop stale listing entries so a second panel cannot steal the chat.

* fix(ai): reject malformed /rebind numbers

Require the entire trimmed argument to be digits so /rebind 1foo and
/rebind 1.5 show usage instead of silently targeting index 1.

---------

Co-authored-by: binaricat <binaricat@users.noreply.github.com>
Co-authored-by: 陈大猫 <16399091+binaricat@users.noreply.github.com>
2026-10-27 20:26:21 -07:00

230 lines
7.5 KiB
TypeScript

export interface AIQuickMessage {
id: string;
/** Display label shown in pickers and settings. */
name: string;
/** Slash-command token, e.g. `status` for `/status`. */
slug: string;
/** Prompt text inserted into the composer when selected. */
content: string;
/** Optional short hint shown in the slash picker. */
description?: string;
}
export interface UserSkillSlashOption {
id: string;
slug: string;
name: string;
description: string;
}
export type SystemSlashCommandSlug = 'stop' | 'compact' | 'rename' | 'chats' | 'rebind';
export interface SystemSlashCommand {
slug: SystemSlashCommandSlug;
name: string;
descriptionKey: string;
}
export type SlashCommandItem =
| { kind: 'quickMessage'; message: AIQuickMessage }
| { kind: 'system'; command: SystemSlashCommand }
| { kind: 'skill'; skill: UserSkillSlashOption };
export const QUICK_MESSAGE_LIMITS = {
name: 120,
slug: 48,
description: 240,
content: 10000,
maxItems: 200,
} as const;
const SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
export function normalizeQuickMessageSlug(input: string): string {
return input
.trim()
.toLowerCase()
.replace(/[^a-z0-9]+/g, '-')
.replace(/^-+|-+$/g, '')
.slice(0, QUICK_MESSAGE_LIMITS.slug);
}
export function isValidQuickMessageSlug(slug: string): boolean {
return slug.length > 0 && SLUG_PATTERN.test(slug);
}
export function slugFromQuickMessageName(name: string): string {
return normalizeQuickMessageSlug(name);
}
function clampString(value: unknown, maxLen: number): string {
if (typeof value !== 'string') return '';
return value.slice(0, maxLen);
}
/** Validate and dedupe quick messages from localStorage or cloud sync. */
export function sanitizeQuickMessages(raw: unknown): AIQuickMessage[] {
if (!Array.isArray(raw)) return [];
const seenSlugs = new Set<string>();
const result: AIQuickMessage[] = [];
for (const entry of raw) {
if (!entry || typeof entry !== 'object') continue;
const record = entry as Record<string, unknown>;
const idRaw = typeof record.id === 'string' ? record.id.trim() : '';
const id = idRaw.length > 0 ? idRaw.slice(0, 64) : createQuickMessageId();
const name = clampString(record.name, QUICK_MESSAGE_LIMITS.name).trim();
const slug = normalizeQuickMessageSlug(clampString(record.slug, QUICK_MESSAGE_LIMITS.slug));
const content = clampString(record.content, QUICK_MESSAGE_LIMITS.content).trim();
const description = clampString(record.description, QUICK_MESSAGE_LIMITS.description).trim();
if (!name || !isValidQuickMessageSlug(slug) || !content) continue;
if (seenSlugs.has(slug)) continue;
seenSlugs.add(slug);
result.push({
id,
name,
slug,
content,
description: description || undefined,
});
if (result.length >= QUICK_MESSAGE_LIMITS.maxItems) break;
}
return result;
}
export function filterQuickMessages(
messages: AIQuickMessage[],
query: string,
): AIQuickMessage[] {
const lowerQuery = query.trim().toLowerCase();
if (!lowerQuery) return messages;
return messages.filter((message) => {
const slug = message.slug.toLowerCase();
const name = message.name.toLowerCase();
return slug.startsWith(lowerQuery) || name.includes(lowerQuery);
});
}
export function filterUserSkillsForSlash(
skills: UserSkillSlashOption[],
query: string,
): UserSkillSlashOption[] {
return skills.filter((skill) => {
if (typeof skill.slug !== 'string' || skill.slug.length === 0) return false;
if (!slashQueryMatches(query, skill.slug, skill.name)) return false;
return true;
});
}
export const SYSTEM_BUILTIN_SLASH_COMMANDS: SystemSlashCommand[] = [
{ slug: 'compact', name: 'Compact context', descriptionKey: 'ai.chat.slashCompactDesc' },
{ slug: 'stop', name: 'Stop', descriptionKey: 'ai.chat.slashStopDesc' },
{ slug: 'rename', name: 'Rename chat', descriptionKey: 'ai.chat.slashRenameDesc' },
{ slug: 'chats', name: 'List chats', descriptionKey: 'ai.chat.slashChatsDesc' },
{ slug: 'rebind', name: 'Rebind chat', descriptionKey: 'ai.chat.slashRebindDesc' },
];
export function filterSystemSlashCommands(
commands: SystemSlashCommand[],
query: string,
): SystemSlashCommand[] {
const lowerQuery = query.trim().toLowerCase();
if (!lowerQuery) return commands;
return commands.filter((command) => (
command.slug.startsWith(lowerQuery) || command.name.toLowerCase().includes(lowerQuery)
));
}
function slashQueryMatches(query: string, slug: string, name: string): boolean {
const lowerQuery = query.trim().toLowerCase();
if (!lowerQuery) return true;
return slug.toLowerCase().startsWith(lowerQuery) || name.toLowerCase().includes(lowerQuery);
}
export function buildSlashCommandItems(
quickMessages: AIQuickMessage[],
userSkills: UserSkillSlashOption[],
query: string,
includeSystemCommands = false,
): SlashCommandItem[] {
const systemCommands = includeSystemCommands
? filterSystemSlashCommands(SYSTEM_BUILTIN_SLASH_COMMANDS, query)
: [];
const systemSlugs = new Set<string>(SYSTEM_BUILTIN_SLASH_COMMANDS.map((command) => command.slug));
const reservedSlugs = new Set([
...quickMessages.map((message) => message.slug),
...(includeSystemCommands ? [...systemSlugs] : []),
]);
const filteredMessages = filterQuickMessages(quickMessages, query)
.filter((message) => !systemSlugs.has(message.slug));
return [
...systemCommands.map((command) => ({
kind: 'system' as const,
command,
})),
...filteredMessages.map((message) => ({
kind: 'quickMessage' as const,
message,
})),
...filterUserSkillsForSlash(userSkills, query)
.filter((skill) => !reservedSlugs.has(skill.slug))
.map((skill) => ({
kind: 'skill' as const,
skill,
})),
];
}
export function getSlashCommandItemKey(item: SlashCommandItem): string {
if (item.kind === 'quickMessage') return `qm:${item.message.id}`;
if (item.kind === 'system') return `sys:${item.command.slug}`;
return `sk:${item.skill.id}`;
}
export function getSlashCommandItemId(item: SlashCommandItem): string {
if (item.kind === 'quickMessage') return item.message.id;
if (item.kind === 'system') return item.command.slug;
return item.skill.id;
}
export function createQuickMessageId(): string {
return `qm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
}
export function isSystemStopSlashCommand(input: string): boolean {
const trimmed = input.trim();
return /^\/stop(?:\s|$)/i.test(trimmed) || trimmed.toLowerCase() === '/stop';
}
export function getSystemSlashCommand(input: string): SystemSlashCommandSlug | null {
const trimmed = input.trim().toLowerCase();
if (/^\/stop(?:\s|$)/.test(trimmed)) return 'stop';
if (trimmed === '/compact') return 'compact';
if (/^\/rename(?:\s|$)/.test(trimmed)) return 'rename';
if (trimmed === '/chats') return 'chats';
if (/^\/rebind(?:\s|$)/.test(trimmed)) return 'rebind';
return null;
}
/**
* Extracts the argument from a `/rebind <n>` submission (the 1-based number
* of a dangling entry in the last `/chats` listing). Returns the empty string
* when no argument was provided (the caller shows a usage hint).
*/
export function getRebindSlashCommandArg(input: string): string {
return input.trim().replace(/^\/rebind\s*/i, '').trim();
}
/**
* Extracts the new title from a `/rename <title>` submission. Returns the
* empty string when no title was provided (the caller shows a usage hint).
*/
export function getRenameSlashCommandTitle(input: string): string {
return input.trim().replace(/^\/rename\s*/i, '').trim();
}