Store and search data

import { LuaTool, Data } from 'lua-cli';
import { z } from 'zod';

export default class AddKnownIssueTool implements LuaTool {
  name = 'add_known_issue';
  description = 'Record a known product issue and its workaround so support can find it later.';
  inputSchema = z.object({
    product: z.string().describe('Product code, for example router-x1'),
    title: z.string().describe('One-line summary of the issue'),
    workaround: z.string().describe('What the customer can do until it is fixed'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    // Everything a support question might mention goes into the indexed text.
    const searchText = `${input.product} ${input.title} ${input.workaround}`;
    const entry = await Data.create('known-issues', { ...input, status: 'open' }, searchText);
    return { id: entry.id, product: entry.product, status: entry.status };
  }
}

import { LuaTool, Data } from 'lua-cli';
import { z } from 'zod';

export default class FindKnownIssueTool implements LuaTool {
  name = 'find_known_issue';
  description = "Find known issues that match a customer's description of a problem.";
  inputSchema = z.object({
    problem: z.string().describe("The problem in the customer's own words"),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const matches = await Data.search('known-issues', input.problem, 5, 0.7);
    return matches.map((match) => ({
      id: match.id,
      product: match.product,
      title: match.title,
      workaround: match.workaround,
      score: match.score,
    }));
  }
}

import { LuaTool, Data } from 'lua-cli';
import { z } from 'zod';

export default class ListOpenIssuesTool implements LuaTool {
  name = 'list_open_issues';
  description = 'List the unresolved known issues for one product.';
  inputSchema = z.object({
    product: z.string().describe('Product code, for example router-x1'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const page = await Data.get(
      'known-issues',
      { product: input.product, status: { $ne: 'resolved' } },
      1,
      20
    );
    return {
      total: page.pagination.totalCount,
      issues: page.data.map((entry) => ({ id: entry.id, ...entry.data })),
    };
  }
}

import { LuaTool, Data } from 'lua-cli';
import { z } from 'zod';

export default class ResolveKnownIssueTool implements LuaTool {
  name = 'resolve_known_issue';
  description = 'Mark a known issue as resolved, or remove it when it was recorded by mistake.';
  inputSchema = z.object({
    id: z.string().describe('The entry id returned by add_known_issue'),
    remove: z.boolean().default(false).describe('True to delete the entry instead of resolving it'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    if (input.remove) {
      await Data.delete('known-issues', input.id);
      return { id: input.id, removed: true };
    }
    await Data.update('known-issues', input.id, {
      status: 'resolved',
      resolvedAt: new Date().toISOString(),
    });
    return { id: input.id, status: 'resolved' };
  }
}

import { LuaSkill } from 'lua-cli';
import AddKnownIssueTool from './tools/AddKnownIssueTool';
import FindKnownIssueTool from './tools/FindKnownIssueTool';
import ListOpenIssuesTool from './tools/ListOpenIssuesTool';
import ResolveKnownIssueTool from './tools/ResolveKnownIssueTool';

export default new LuaSkill({
  name: 'known-issues',
  description: 'Known product issues and their workarounds',
  context:
    'When a customer describes a problem, call find_known_issue with their words before answering ' +
    'and offer the workaround. Only support staff add or resolve issues; refer customers to support.',
  tools: [new AddKnownIssueTool(), new FindKnownIssueTool(), new ListOpenIssuesTool(), new ResolveKnownIssueTool()],
});

…
Tool returned: Array[1] of Object — fields: id, product, title, workaround, score
Output:
[
  {
    id: '7a112ce1-5c55-4973-b4f9-ec482d21b60c',
    product: 'router-x1',
    title: 'Wi-Fi drops every hour',
    workaround: 'Disable band steering in the admin panel',
    score: 0.734224796295166
  }
]

{
  "id": "3f0b6a52-…",
  "orgId": "<your-org-id>",
  "name": "product_catalog",
  "readers": ["<support-agent-id>", "<sales-agent-id>"],
  "writers": ["<catalog-agent-id>"],
  "createdBy": "<your-user-id>",
  "updatedBy": "<your-user-id>",
  "createdAt": 1791710400000,
  "updatedAt": 1791710400000
}

import { LuaJob, Data, env } from 'lua-cli';

export default new LuaJob({
  name: 'sync-catalog',
  description: 'Copy the product catalog into the shared collection every night',
  schedule: { type: 'cron', expression: '0 2 * * *', timezone: 'Europe/London' },
  timeout: 120,
  async execute() {
    const catalog = Data.shared('product_catalog');
    const res = await fetch(`${env('CATALOG_API_URL')}/products`);
    const products: Array<{ sku: string; name: string; summary: string; price: number }> = await res.json();

    for (const product of products) {
      const existing = await catalog.get('products', { sku: product.sku }, 1, 1);
      const searchText = `${product.name} ${product.summary}`;
      if (existing.data.length > 0) {
        await catalog.update('products', existing.data[0].id, product, searchText);
      } else {
        await catalog.create('products', product, searchText);
      }
    }
    return { synced: products.length };
  },
});

import { LuaTool, Data } from 'lua-cli';
import { z } from 'zod';

export default class FindProductTool implements LuaTool {
  name = 'find_product';
  description = 'Find products in the shared catalog that match what the customer is looking for.';
  inputSchema = z.object({
    query: z.string().describe("What the customer is looking for, in their own words"),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const matches = await Data.shared('product_catalog').search('products', input.query, 5, 0.7);
    return matches.map((match) => ({ sku: match.sku, name: match.name, price: match.price, score: match.score }));
  }
}