[Init] Initial commit - NetMesh terminal manager

infrastructure/ai/quickMessages.ts

@@ -0,0 +1,206 @@
+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';
+
+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' },
+];
+
+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';
+  return null;
+}