} catch (final IOException e) {
                        throw new IORuntimeException(e);
                    }
                    logFileItems.add(map);
                });
            } catch (final Exception e) {
                throw new FessSystemException("Failed to access log files.", e);
            }
        }
        return logFileItems;
    }

# Admin UI: http://localhost:8080/admin/ (admin/admin)

# From command line (after building)
./bin/fess
```

### Code Formatting
```bash
# Format code
mvn formatter:format

# Add license headers
mvn license:format
```

## Tech Stack

- **Web Framework**: LastaFlute (MVC framework)
- **DI Container**: Lasta Di
- **Data Access**: DBFlute (type-safe ORM for OpenSearch)

 *
 * <p><b>Warning:</b> The methods of {@code ForwardingBlockingDeque} forward <b>indiscriminately</b>
 * to the methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change
 * the behaviour of {@link #offer} which can lead to unexpected behaviour. In this case, you should
 * override {@code offer} as well, either providing your own implementation, or delegating to the

    if (predicate == null) {
      throw new IllegalArgumentException(
          expectedThrowable
              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {

    if (predicate == null) {
      throw new IllegalArgumentException(
          expectedThrowable
              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {

    if (predicate == null) {
      throw new IllegalArgumentException(
          expectedThrowable
              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {

      this.backingList = backingList;
    }

    @Override
    protected List<T> delegate() {
      return backingList;
    }

    @Override
    public boolean add(T element) {
      return standardAdd(element);
    }

    @Override
    public boolean addAll(Collection<? extends T> collection) {
      return standardAddAll(collection);
    }

    @Override

      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public boolean add(E element) {
      return standardAdd(element);
    }

    @Override
    public boolean addAll(Collection<? extends E> collection) {
      return standardAddAll(collection);
    }

    @Override

    if (predicate == null) {
      throw new IllegalArgumentException(
          expectedThrowable
              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {

            final List<String> tagList = new ArrayList<>();
            final String key = ComponentUtil.getVirtualHostHelper().getVirtualHostKey();
            if (StringUtil.isNotBlank(key)) {
                tagList.add(key);
            }
            runtime.registerData("popularWords", popularWordHelper.getWordList(SearchRequestType.SEARCH, null,
                    tagList.toArray(new String[tagList.size()]), null, null, null));
        }