mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-21 23:50:45 +00:00
* 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>
230 lines
7.5 KiB
TypeScript
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();
|
|
}
|