Files
Netcatty/infrastructure/ai/quickMessages.test.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

148 lines
6.0 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import {
buildSlashCommandItems,
filterQuickMessages,
getRebindSlashCommandArg,
getRenameSlashCommandTitle,
getSystemSlashCommand,
isValidQuickMessageSlug,
normalizeQuickMessageSlug,
sanitizeQuickMessages,
slugFromQuickMessageName,
} from './quickMessages';
test('normalizeQuickMessageSlug lowercases and hyphenates', () => {
assert.equal(normalizeQuickMessageSlug('Check Disk Space'), 'check-disk-space');
assert.equal(normalizeQuickMessageSlug(' foo__bar!! '), 'foo-bar');
});
test('slugFromQuickMessageName mirrors normalize', () => {
assert.equal(slugFromQuickMessageName('Check Disk'), 'check-disk');
});
test('isValidQuickMessageSlug accepts simple tokens', () => {
assert.equal(isValidQuickMessageSlug('disk-check'), true);
assert.equal(isValidQuickMessageSlug('Disk'), false);
assert.equal(isValidQuickMessageSlug(''), false);
});
test('filterQuickMessages matches slug prefix and name substring', () => {
const messages = [
{ id: '1', name: 'Check disk', slug: 'disk', content: 'df -h' },
{ id: '2', name: 'List processes', slug: 'ps', content: 'ps aux' },
];
assert.equal(filterQuickMessages(messages, 'di').length, 1);
assert.equal(filterQuickMessages(messages, 'proc').length, 1);
assert.equal(filterQuickMessages(messages, '').length, 2);
});
test('sanitizeQuickMessages rejects invalid and dedupes slugs', () => {
const result = sanitizeQuickMessages([
{ id: '1', name: 'Valid', slug: 'valid', content: 'hello' },
{ id: '2', name: 'Duplicate', slug: 'valid', content: 'ignored' },
{ id: '3', name: '', slug: 'empty', content: 'nope' },
{ id: '4', name: 'Bad slug', slug: '!!!', content: 'nope' },
null,
'not-an-object',
]);
assert.equal(result.length, 1);
assert.equal(result[0]?.slug, 'valid');
});
test('buildSlashCommandItems prefers quick messages over conflicting skill slugs', () => {
const items = buildSlashCommandItems(
[{ id: '1', name: 'Disk', slug: 'disk', content: 'df -h' }],
[{ id: 's1', slug: 'disk', name: 'Disk skill', description: '' }],
'',
);
assert.equal(items.length, 1);
assert.equal(items[0]?.kind, 'quickMessage');
});
test('buildSlashCommandItems excludes skills whose slug matches any quick message', () => {
const items = buildSlashCommandItems(
[{ id: '1', name: 'Disk check', slug: 'disk', content: 'df -h' }],
[{ id: 's1', slug: 'disk', name: 'Disk skill label', description: '' }],
'label',
);
assert.equal(items.length, 0);
});
test('buildSlashCommandItems includes built-in commands for the composer picker', () => {
const items = buildSlashCommandItems([], [], 'com', true);
assert.deepEqual(items.map((item) => item.kind === 'system' ? item.command.slug : item.kind), ['compact']);
});
test('getSystemSlashCommand recognizes /compact and /stop only', () => {
assert.equal(getSystemSlashCommand('/compact'), 'compact');
assert.equal(getSystemSlashCommand(' /Compact '), 'compact');
assert.equal(getSystemSlashCommand('/compact now'), null);
assert.equal(getSystemSlashCommand('/stop'), 'stop');
assert.equal(getSystemSlashCommand('/stop please'), 'stop');
assert.equal(getSystemSlashCommand('/stopx'), null);
assert.equal(getSystemSlashCommand('/clear'), null);
assert.equal(getSystemSlashCommand('/compress'), null);
});
test('getSystemSlashCommand recognizes /rename with an argument and bare /chats', () => {
assert.equal(getSystemSlashCommand('/rename'), 'rename');
assert.equal(getSystemSlashCommand('/rename New title'), 'rename');
assert.equal(getSystemSlashCommand(' /RENAME stuff '), 'rename');
assert.equal(getSystemSlashCommand('/renamex'), null);
assert.equal(getSystemSlashCommand('/chats'), 'chats');
assert.equal(getSystemSlashCommand(' /Chats '), 'chats');
assert.equal(getSystemSlashCommand('/chats now'), null);
assert.equal(getSystemSlashCommand('/chat'), null);
});
test('getRenameSlashCommandTitle extracts the argument and trims it', () => {
assert.equal(getRenameSlashCommandTitle('/rename New title'), 'New title');
assert.equal(getRenameSlashCommandTitle(' /RENAME spaced '), 'spaced');
assert.equal(getRenameSlashCommandTitle('/rename'), '');
assert.equal(getRenameSlashCommandTitle('/rename '), '');
});
test('getSystemSlashCommand recognizes /rebind with an argument', () => {
assert.equal(getSystemSlashCommand('/rebind'), 'rebind');
assert.equal(getSystemSlashCommand('/rebind 2'), 'rebind');
assert.equal(getSystemSlashCommand(' /Rebind 1 '), 'rebind');
assert.equal(getSystemSlashCommand('/rebindx'), null);
assert.equal(getSystemSlashCommand('/re'), null);
});
test('getRebindSlashCommandArg extracts the dangling entry number', () => {
assert.equal(getRebindSlashCommandArg('/rebind 2'), '2');
assert.equal(getRebindSlashCommandArg(' /REBIND 1 '), '1');
assert.equal(getRebindSlashCommandArg('/rebind'), '');
assert.equal(getRebindSlashCommandArg('/rebind '), '');
});
test('buildSlashCommandItems reserves system slugs over quick messages and skills', () => {
const emptyQuery = buildSlashCommandItems([], [], '', true);
assert.deepEqual(
emptyQuery.filter((item) => item.kind === 'system').map((item) => item.kind === 'system' ? item.command.slug : ''),
['compact', 'stop', 'rename', 'chats', 'rebind'],
);
const withCollision = buildSlashCommandItems(
[{ id: '1', name: 'User compact', slug: 'compact', content: 'do not run' }],
[{ id: 's1', slug: 'stop', name: 'Stop skill', description: '' }],
'',
true,
);
assert.deepEqual(
withCollision.map((item) => (
item.kind === 'system' ? `sys:${item.command.slug}`
: item.kind === 'quickMessage' ? `qm:${item.message.slug}`
: `sk:${item.skill.slug}`
)),
['sys:compact', 'sys:stop', 'sys:rename', 'sys:chats', 'sys:rebind'],
);
});
test('sanitizeQuickMessages returns empty array for non-array input', () => {
assert.deepEqual(sanitizeQuickMessages(null), []);
assert.deepEqual(sanitizeQuickMessages({}), []);
});