helix-assistant-cli 0.2.4 → 0.2.7

package/dist/index.js

@@ -70,14 +70,16 @@ const program = new commander_1.Command();
 program
     .name('helix')
     .description('HELIX - Interactive Terminal CLI for Windows AI Desktop Agent')
-    .version('0.1.0')
+    .version('0.2.7')
     .option('-u, --ws-url <url>', 'URL del servidor WebSocket del agente', (0, env_1.getWsUrl)())
     .option('-t, --token <token>', 'Token de autenticación WebSocket de HELIX', (0, env_1.getWsToken)())
+    .option('--plain', 'Desactivar formato enriquecido de Markdown y mostrar texto plano sin asteriscos')
     .action(async (options) => {
     // Default action: start interactive chat REPL
     const repl = new repl_1.HelixRepl({
         wsUrl: options.wsUrl || (0, env_1.getWsUrl)(),
         wsToken: options.token || (0, env_1.getWsToken)(),
+        plain: Boolean(options.plain),
     });
     await repl.start();
 });
@@ -89,6 +91,7 @@ program
     const repl = new repl_1.HelixRepl({
         wsUrl: opts.wsUrl || (0, env_1.getWsUrl)(),
         wsToken: opts.token || (0, env_1.getWsToken)(),
+        plain: Boolean(opts.plain),
     });
     await repl.start();
 });

package/dist/skills/user-skill-discovery.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolves the only user-controlled directory used by the CLI skill catalog.
+ * HELIX_SKILLS_DIR is explicit; otherwise it follows the agent's settings path.
+ */
+export declare function getUserSkillsDirectory(): string;
+/**
+ * Returns names only. The file contents are deliberately never read: skill
+ * instructions can contain secrets and are not needed for autocomplete.
+ * Discovery is shallow and rejects symlinked entries to avoid following paths
+ * outside the user's skills directory.
+ */
+export declare function discoverUserSkillNames(skillsDirectory?: string): string[];

package/dist/skills/user-skill-discovery.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserSkillsDirectory = getUserSkillsDirectory;
+exports.discoverUserSkillNames = discoverUserSkillNames;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const env_1 = require("../config/env");
+const SKILL_NAME = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+/**
+ * Resolves the only user-controlled directory used by the CLI skill catalog.
+ * HELIX_SKILLS_DIR is explicit; otherwise it follows the agent's settings path.
+ */
+function getUserSkillsDirectory() {
+    const configured = process.env.HELIX_SKILLS_DIR?.trim();
+    if (configured)
+        return path_1.default.resolve(configured);
+    return path_1.default.join(path_1.default.dirname((0, env_1.getSettingsFilePath)()), 'skills');
+}
+/**
+ * Returns names only. The file contents are deliberately never read: skill
+ * instructions can contain secrets and are not needed for autocomplete.
+ * Discovery is shallow and rejects symlinked entries to avoid following paths
+ * outside the user's skills directory.
+ */
+function discoverUserSkillNames(skillsDirectory = getUserSkillsDirectory()) {
+    const root = path_1.default.resolve(skillsDirectory);
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const names = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.isSymbolicLink() || !SKILL_NAME.test(entry.name))
+            continue;
+        const skillFile = path_1.default.join(root, entry.name, 'SKILL.md');
+        try {
+            const file = fs_1.default.lstatSync(skillFile);
+            if (file.isFile() && !file.isSymbolicLink())
+                names.push(entry.name);
+        }
+        catch {
+            // Ignore incomplete, inaccessible, or malformed user entries.
+        }
+    }
+    return names.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+}

package/dist/ui/autocomplete.d.ts

@@ -8,8 +8,12 @@ export declare const SLASH_COMMANDS: CommandDefinition[];
 export declare class Autocompleter {
     private client?;
     private skills;
+    private remoteSkills;
+    private localSkills;
     private mcpTools;
-    constructor(client?: AgentClient | undefined);
+    private readonly userSkillsDirectory;
+    constructor(client?: AgentClient | undefined, userSkillsDirectory?: string);
+    private refreshLocalSkills;
     refreshSuggestions(): Promise<void>;
     getSkills(): string[];
     getMcpTools(): string[];

package/dist/ui/autocomplete.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Autocompleter = exports.SLASH_COMMANDS = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const colors_1 = require("./colors");
+const user_skill_discovery_1 = require("../skills/user-skill-discovery");
 exports.SLASH_COMMANDS = [
     { command: '/create-skill', description: 'Crear una nueva skill interactiva para HELIX' },
     { command: '/skill', description: 'Listar o inspeccionar skills registradas', usage: '/skill [nombre]' },
@@ -26,9 +27,20 @@ exports.SLASH_COMMANDS = [
 class Autocompleter {
     client;
     skills = [];
+    remoteSkills = [];
+    localSkills = [];
     mcpTools = [];
-    constructor(client) {
+    userSkillsDirectory;
+    constructor(client, userSkillsDirectory = (0, user_skill_discovery_1.getUserSkillsDirectory)()) {
         this.client = client;
+        this.userSkillsDirectory = userSkillsDirectory;
+        this.refreshLocalSkills();
+    }
+    refreshLocalSkills() {
+        this.localSkills = (0, user_skill_discovery_1.discoverUserSkillNames)(this.userSkillsDirectory);
+        const baseSkills = this.client ? this.remoteSkills : this.skills;
+        this.skills = [...new Set([...baseSkills, ...this.localSkills])]
+            .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
     }
     async refreshSuggestions() {
         if (!this.client || !this.client.connected)
@@ -36,7 +48,7 @@ class Autocompleter {
         try {
             const skills = await this.client.getSkills();
             if (skills) {
-                this.skills = skills.map((s) => s.name);
+                this.remoteSkills = skills.map((s) => s.name);
             }
         }
         catch {
@@ -60,6 +72,7 @@ class Autocompleter {
         catch {
             // Ignored
         }
+        this.refreshLocalSkills();
     }
     getSkills() {
         return this.skills;
@@ -72,6 +85,9 @@ class Autocompleter {
      * (line: string) => [string[], string]
      */
     completer(line) {
+        // A skill may be created by another HELIX surface while the REPL is open.
+        // Keep Tab completion current without exposing the skill file contents.
+        this.refreshLocalSkills();
         const trimmed = line.trimStart();
         // 1. Skill sub-arguments for /skill <name>
         if (trimmed.startsWith('/skill ')) {

package/dist/ui/markdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Formats Markdown text for optimal display in terminal emulators,
+ * resolving visual noise from unparsed asterisks (*, **) and headers.
+ */
+export declare function formatTerminalMarkdown(content: string, plain?: boolean): string;

package/dist/ui/markdown.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTerminalMarkdown = formatTerminalMarkdown;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Formats Markdown text for optimal display in terminal emulators,
+ * resolving visual noise from unparsed asterisks (*, **) and headers.
+ */
+function formatTerminalMarkdown(content, plain = false) {
+    if (!content)
+        return '';
+    const lines = content.split('\n');
+    const formattedLines = lines.map((line) => {
+        let formatted = line;
+        // Headers (#, ##, ###)
+        const headerMatch = formatted.match(/^(#{1,6})\s+(.*)$/);
+        if (headerMatch) {
+            const title = headerMatch[2].trim();
+            if (plain) {
+                return title.toUpperCase();
+            }
+            return chalk_1.default.hex('#FF9F1C').bold(title);
+        }
+        // Bullet lists (* item, - item)
+        if (/^\s*[*+-]\s+/.test(formatted)) {
+            formatted = formatted.replace(/^(\s*)[*+-]\s+/, (_m, indent) => {
+                return plain ? `${indent}- ` : `${indent}${chalk_1.default.hex('#FF8C00')('•')} `;
+            });
+        }
+        // Inline bold (**text** or __text__)
+        formatted = formatted.replace(/(\*\*|__)(.*?)\1/g, (_m, _delim, text) => {
+            return plain ? text : chalk_1.default.bold(text);
+        });
+        // Inline italics (*text* or _text_)
+        formatted = formatted.replace(/(?<!\*)\*([^*]+)\*(?!\*)|(?<!_)_([^_]+)_(?!_)/g, (_m, t1, t2) => {
+            const text = t1 || t2;
+            return plain ? text : chalk_1.default.whiteBright(text);
+        });
+        // Inline code (`code`)
+        formatted = formatted.replace(/`([^`]+)`/g, (_m, code) => {
+            return plain ? code : chalk_1.default.cyan(code);
+        });
+        return formatted;
+    });
+    return formattedLines.join('\n');
+}

package/dist/ui/repl.d.ts

@@ -1,6 +1,7 @@
 export interface ReplOptions {
     wsUrl: string;
     wsToken?: string;
+    plain?: boolean;
 }
 export declare class HelixRepl {
     private options;
@@ -15,6 +16,7 @@ export declare class HelixRepl {
     private activeTaskId;
     private activeTasksCount;
     private isProcessingPrompt;
+    private plain;
     constructor(options: ReplOptions);
     start(): Promise<void>;
     private _syncSettings;

package/dist/ui/repl.js

@@ -16,6 +16,7 @@ const skills_1 = require("../commands/skills");
 const mcp_1 = require("../commands/mcp");
 const mic_1 = require("../commands/mic");
 const browser_1 = require("../commands/browser");
+const markdown_1 = require("./markdown");
 class HelixRepl {
     options;
     rl = null;
@@ -29,9 +30,11 @@ class HelixRepl {
     activeTaskId = null;
     activeTasksCount = 0;
     isProcessingPrompt = false;
+    plain = false;
     constructor(options) {
         this.options = options;
         this.conversationId = `cli_conv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        this.plain = Boolean(options.plain);
         this.client = new agent_client_1.AgentClient({
             wsUrl: options.wsUrl,
             wsToken: options.wsToken,
@@ -150,8 +153,9 @@ class HelixRepl {
             // Branded header
             console.log('');
             console.log(`  ${chalk_1.default.hex('#FF8C00').bold('⬡ HELIX')}${modelBadge}`);
-            // Content with subtle left border
-            const contentLines = content.trim().split('\n');
+            // Content with subtle left border and clean Markdown formatting
+            const formatted = (0, markdown_1.formatTerminalMarkdown)(content, this.plain);
+            const contentLines = formatted.trim().split('\n');
             for (const line of contentLines) {
                 console.log(`  ${chalk_1.default.gray('│')} ${line}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helix-assistant-cli",
-  "version": "0.2.4",
+  "version": "0.2.7",
   "description": "HELIX - Interactive Terminal CLI for Windows AI Desktop Agent",
   "private": false,
   "publishConfig": {
@@ -30,4 +30,4 @@
     "@types/ws": "^8.5.10",
     "typescript": "^5.3.0"
   }
-}
+}

package/src/index.ts

@@ -73,14 +73,16 @@ const program = new Command();
 program
   .name('helix')
   .description('HELIX - Interactive Terminal CLI for Windows AI Desktop Agent')
-  .version('0.1.0')
+  .version('0.2.7')
   .option('-u, --ws-url <url>', 'URL del servidor WebSocket del agente', getWsUrl())
   .option('-t, --token <token>', 'Token de autenticación WebSocket de HELIX', getWsToken())
+  .option('--plain', 'Desactivar formato enriquecido de Markdown y mostrar texto plano sin asteriscos')
   .action(async (options) => {
     // Default action: start interactive chat REPL
     const repl = new HelixRepl({
       wsUrl: options.wsUrl || getWsUrl(),
       wsToken: options.token || getWsToken(),
+      plain: Boolean(options.plain),
     });
     await repl.start();
   });
@@ -93,6 +95,7 @@ program
     const repl = new HelixRepl({
       wsUrl: opts.wsUrl || getWsUrl(),
       wsToken: opts.token || getWsToken(),
+      plain: Boolean(opts.plain),
     });
     await repl.start();
   });

package/src/skills/user-skill-discovery.ts

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import path from 'path';
+import { getSettingsFilePath } from '../config/env';
+
+const SKILL_NAME = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+
+/**
+ * Resolves the only user-controlled directory used by the CLI skill catalog.
+ * HELIX_SKILLS_DIR is explicit; otherwise it follows the agent's settings path.
+ */
+export function getUserSkillsDirectory(): string {
+  const configured = process.env.HELIX_SKILLS_DIR?.trim();
+  if (configured) return path.resolve(configured);
+  return path.join(path.dirname(getSettingsFilePath()), 'skills');
+}
+
+/**
+ * Returns names only. The file contents are deliberately never read: skill
+ * instructions can contain secrets and are not needed for autocomplete.
+ * Discovery is shallow and rejects symlinked entries to avoid following paths
+ * outside the user's skills directory.
+ */
+export function discoverUserSkillNames(skillsDirectory = getUserSkillsDirectory()): string[] {
+  const root = path.resolve(skillsDirectory);
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const names: string[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.isSymbolicLink() || !SKILL_NAME.test(entry.name)) continue;
+
+    const skillFile = path.join(root, entry.name, 'SKILL.md');
+    try {
+      const file = fs.lstatSync(skillFile);
+      if (file.isFile() && !file.isSymbolicLink()) names.push(entry.name);
+    } catch {
+      // Ignore incomplete, inaccessible, or malformed user entries.
+    }
+  }
+  return names.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+}

package/src/ui/autocomplete.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import type { AgentClient } from '../client/agent-client';
 import { formatSkill, formatMcp, ORANGE, CYAN, MAGENTA, DIM } from './colors';
+import { discoverUserSkillNames, getUserSkillsDirectory } from '../skills/user-skill-discovery';
 
 export interface CommandDefinition {
   command: string;
@@ -28,16 +29,29 @@ export const SLASH_COMMANDS: CommandDefinition[] = [
 
 export class Autocompleter {
   private skills: string[] = [];
+  private remoteSkills: string[] = [];
+  private localSkills: string[] = [];
   private mcpTools: string[] = [];
+  private readonly userSkillsDirectory: string;
 
-  constructor(private client?: AgentClient) {}
+  constructor(private client?: AgentClient, userSkillsDirectory = getUserSkillsDirectory()) {
+    this.userSkillsDirectory = userSkillsDirectory;
+    this.refreshLocalSkills();
+  }
+
+  private refreshLocalSkills(): void {
+    this.localSkills = discoverUserSkillNames(this.userSkillsDirectory);
+    const baseSkills = this.client ? this.remoteSkills : this.skills;
+    this.skills = [...new Set([...baseSkills, ...this.localSkills])]
+      .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+  }
 
   public async refreshSuggestions(): Promise<void> {
     if (!this.client || !this.client.connected) return;
     try {
       const skills = await this.client.getSkills();
       if (skills) {
-        this.skills = skills.map((s) => s.name);
+        this.remoteSkills = skills.map((s) => s.name);
       }
     } catch {
       // Ignored if client is offline
@@ -60,6 +74,8 @@ export class Autocompleter {
     } catch {
       // Ignored
     }
+
+    this.refreshLocalSkills();
   }
 
   public getSkills(): string[] {
@@ -75,6 +91,9 @@ export class Autocompleter {
    * (line: string) => [string[], string]
    */
   public completer(line: string): [string[], string] {
+    // A skill may be created by another HELIX surface while the REPL is open.
+    // Keep Tab completion current without exposing the skill file contents.
+    this.refreshLocalSkills();
     const trimmed = line.trimStart();
 
     // 1. Skill sub-arguments for /skill <name>

package/src/ui/markdown.ts

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+
+/**
+ * Formats Markdown text for optimal display in terminal emulators,
+ * resolving visual noise from unparsed asterisks (*, **) and headers.
+ */
+export function formatTerminalMarkdown(content: string, plain = false): string {
+  if (!content) return '';
+
+  const lines = content.split('\n');
+  const formattedLines = lines.map((line) => {
+    let formatted = line;
+
+    // Headers (#, ##, ###)
+    const headerMatch = formatted.match(/^(#{1,6})\s+(.*)$/);
+    if (headerMatch) {
+      const title = headerMatch[2].trim();
+      if (plain) {
+        return title.toUpperCase();
+      }
+      return chalk.hex('#FF9F1C').bold(title);
+    }
+
+    // Bullet lists (* item, - item)
+    if (/^\s*[*+-]\s+/.test(formatted)) {
+      formatted = formatted.replace(/^(\s*)[*+-]\s+/, (_m, indent) => {
+        return plain ? `${indent}- ` : `${indent}${chalk.hex('#FF8C00')('•')} `;
+      });
+    }
+
+    // Inline bold (**text** or __text__)
+    formatted = formatted.replace(/(\*\*|__)(.*?)\1/g, (_m, _delim, text) => {
+      return plain ? text : chalk.bold(text);
+    });
+
+    // Inline italics (*text* or _text_)
+    formatted = formatted.replace(/(?<!\*)\*([^*]+)\*(?!\*)|(?<!_)_([^_]+)_(?!_)/g, (_m, t1, t2) => {
+      const text = t1 || t2;
+      return plain ? text : chalk.whiteBright(text);
+    });
+
+    // Inline code (`code`)
+    formatted = formatted.replace(/`([^`]+)`/g, (_m, code) => {
+      return plain ? code : chalk.cyan(code);
+    });
+
+    return formatted;
+  });
+
+  return formattedLines.join('\n');
+}

package/src/ui/repl.ts

@@ -25,10 +25,12 @@ import { handleCreateMcp, handleListMcp } from '../commands/mcp';
 import { handleMicrophoneCommand } from '../commands/mic';
 import { handleBrowserCommand } from '../commands/browser';
 import type { ConfirmationRequest } from '../client/types';
+import { formatTerminalMarkdown } from './markdown';
 
 export interface ReplOptions {
   wsUrl: string;
   wsToken?: string;
+  plain?: boolean;
 }
 
 export class HelixRepl {
@@ -43,9 +45,11 @@ export class HelixRepl {
   private activeTaskId: string | null = null;
   private activeTasksCount: number = 0;
   private isProcessingPrompt: boolean = false;
+  private plain: boolean = false;
 
   constructor(private options: ReplOptions) {
     this.conversationId = `cli_conv_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+    this.plain = Boolean(options.plain);
     this.client = new AgentClient({
       wsUrl: options.wsUrl,
       wsToken: options.wsToken,
@@ -182,8 +186,9 @@ export class HelixRepl {
       console.log('');
       console.log(`  ${chalk.hex('#FF8C00').bold('⬡ HELIX')}${modelBadge}`);
 
-      // Content with subtle left border
-      const contentLines = content.trim().split('\n');
+      // Content with subtle left border and clean Markdown formatting
+      const formatted = formatTerminalMarkdown(content, this.plain);
+      const contentLines = formatted.trim().split('\n');
       for (const line of contentLines) {
         console.log(`  ${chalk.gray('│')} ${line}`);
       }

package/tests/cli.test.ts

@@ -3,6 +3,10 @@ import assert from 'node:assert/strict';
 import { Autocompleter, SLASH_COMMANDS } from '../src/ui/autocomplete';
 import { formatSkill, formatMcp, highlightMentions, ORANGE } from '../src/ui/colors';
 import { getAsciiLogo, getStatusBar, getVoiceIndicator } from '../src/ui/banner';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { discoverUserSkillNames } from '../src/skills/user-skill-discovery';
 
 test('Autocompleter suggests slash commands', () => {
   const completer = new Autocompleter();
@@ -68,6 +72,42 @@ test('Autocompleter handles @skills and #mcps autocompletion', () => {
   assert.deepEqual(skillSub, ['/skill web-search']);
 });
 
+test('User skill discovery is shallow, dynamic, and metadata-only', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'helix-cli-skills-'));
+  try {
+    fs.mkdirSync(path.join(root, 'meeting-notes'));
+    fs.writeFileSync(
+      path.join(root, 'meeting-notes', 'SKILL.md'),
+      '---\nname: meeting-notes\n---\nSECRET_INSTRUCTIONS_SHOULD_NOT_BE_READ',
+      'utf8',
+    );
+    fs.mkdirSync(path.join(root, 'not-a-skill.txt'));
+    fs.mkdirSync(path.join(root, 'nested', 'hidden-skill'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'nested', 'hidden-skill', 'SKILL.md'), 'secret', 'utf8');
+    fs.writeFileSync(path.join(root, 'README.md'), 'not a skill', 'utf8');
+
+    assert.deepEqual(discoverUserSkillNames(root), ['meeting-notes']);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('Autocomplete merges default/remote skills with newly-created user skills', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'helix-cli-refresh-'));
+  try {
+    const completer = new Autocompleter(undefined, root);
+    (completer as any).remoteSkills = ['coding'];
+    (completer as any).skills = ['coding'];
+    fs.mkdirSync(path.join(root, 'custom-review'));
+    fs.writeFileSync(path.join(root, 'custom-review', 'SKILL.md'), '# user skill', 'utf8');
+
+    const [matches] = completer.completer('@custom');
+    assert.deepEqual(matches, ['@custom-review ']);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('Colors: formatSkill applies strong orange formatting', () => {
   const formatted = formatSkill('web-researcher');
   assert.ok(formatted.includes('@web-researcher'));
@@ -185,3 +225,23 @@ test('CLI: run with piped UTF-8 Spanish text with BOM is decoded cleanly', async
   });
 });
 
+
+
+test('Markdown: formatTerminalMarkdown parses bold, headers and bullets cleanly', async () => {
+  const { formatTerminalMarkdown } = await import('../src/ui/markdown');
+  const raw = '# Resumen\n\nAquí hay **texto importante** y un *detalle*:\n* Primer punto\n* Segundo punto\n`código`';
+
+  // Rich format
+  const formatted = formatTerminalMarkdown(raw);
+  assert.ok(!formatted.includes('**texto importante**'));
+  assert.ok(formatted.includes('texto importante'));
+  assert.ok(formatted.includes('• Primer punto'));
+
+  // Plain format
+  const plain = formatTerminalMarkdown(raw, true);
+  assert.ok(!plain.includes('**'));
+  assert.ok(!plain.includes('* Primer punto'));
+  assert.ok(plain.includes('- Primer punto'));
+  assert.ok(plain.includes('texto importante'));
+  assert.ok(plain.includes('RESUMEN'));
+});