Global: add linting and update type names

package.json

@@ -33,6 +33,7 @@
     "build:samples": "npx turbo build --filter=./samples/*",
     "dev": "npx turbo dev",
     "lint": "npx turbo lint",
+    "lint:fix": "npx turbo lint:fix",
     "test": "npx turbo test --concurrency=100%",
     "fmt": "npx prettier --write \"**/*.{js,ts,tsx,md,json}\"",
     "docs:build": "mdbook build book",

packages/ai/eslint.config.js

@@ -0,0 +1 @@
+module.exports = require('@microsoft/spark.config/eslint.config');

packages/ai/package.json

@@ -25,6 +25,8 @@
   ],
   "scripts": {
     "clean": "npx rimraf ./dist",
+    "lint": "npx eslint",
+    "lint:fix": "npx eslint --fix",
     "build": "npx tsup",
     "test": "npx jest"
   },

packages/ai/src/function.ts

@@ -1,14 +1,14 @@
 export type FunctionHandler<T = any> = (args: T) => any | Promise<any>;
 
-export interface Function {
+export type Function = {
   readonly name: string;
   readonly description: string;
   readonly parameters: { [key: string]: any };
   readonly handler: FunctionHandler;
-}
+};
 
-export interface FunctionCall {
+export type FunctionCall = {
   readonly id: string;
   readonly name: string;
   readonly arguments: { [key: string]: any };
-}
+};

packages/ai/src/local-memory.ts

@@ -1,17 +1,17 @@
-import { Memory } from './memory';
+import { IMemory } from './memory';
 import { Message } from './message';
-import { ChatModel } from './models';
+import { IChatModel } from './models';
 
-export interface LocalMemoryOptions {
+export type LocalMemoryOptions = {
   readonly max?: number;
   readonly messages?: Message[];
   readonly collapse?: {
     readonly strategy: 'half' | 'full';
-    readonly model: ChatModel;
+    readonly model: IChatModel;
   };
-}
+};
 
-export class LocalMemory implements Memory {
+export class LocalMemory implements IMemory {
   protected readonly messages: Message[];
   protected readonly options: LocalMemoryOptions;
 
@@ -59,7 +59,7 @@ export class LocalMemory implements Memory {
   async collapse() {
     if (!this.options.collapse) return;
 
-    let start = 0;
+    const start = 0;
     let end = this.length() - 1;
 
     if (this.options.collapse.strategy === 'half') {

packages/ai/src/memory.ts

@@ -1,6 +1,6 @@
 import { Message } from './message';
 
-export interface Memory {
+export interface IMemory {
   push(message: Message): void | Promise<void>;
   pop(): (Message | undefined) | Promise<Message | undefined>;
   values(): Message[] | Promise<Message[]>;

packages/ai/src/message.ts

@@ -2,36 +2,36 @@ import { FunctionCall } from './function';
 
 export type Message = UserMessage | ModelMessage | SystemMessage | FunctionMessage;
 
-export interface UserMessage {
+export type UserMessage = {
   role: 'user';
   content: string | ContentPart[];
-}
+};
 
-export interface ModelMessage {
+export type ModelMessage = {
   role: 'model';
   content?: string;
   function_calls?: FunctionCall[];
-}
+};
 
-export interface SystemMessage {
+export type SystemMessage = {
   role: 'system';
   content: string;
-}
+};
 
-export interface FunctionMessage {
+export type FunctionMessage = {
   role: 'function';
   content?: string;
   function_id: string;
-}
+};
 
 export type ContentPart = TextContentPart | ImageContentPart;
 
-export interface TextContentPart {
+export type TextContentPart = {
   type: 'text';
   text: string;
-}
+};
 
-export interface ImageContentPart {
+export type ImageContentPart = {
   type: 'image_url';
   image_url: string;
-}
+};

packages/ai/src/models/audio.ts

@@ -1,17 +1,17 @@
-export interface TextToAudioParams {
+export type TextToAudioParams = {
   readonly type: string;
   readonly text: string;
   readonly voice: string;
-}
+};
 
-export interface AudioToTextParams {
+export type AudioToTextParams = {
   readonly type: string;
   readonly data: Buffer;
   readonly prompt?: string;
   readonly lang?: string;
-}
+};
 
-export interface AudioModel {
+export interface IAudioModel {
   textToAudio?(params: TextToAudioParams): Promise<Buffer>;
   audioToText?(params: AudioToTextParams): Promise<string>;
 }

packages/ai/src/models/chat.ts

@@ -1,15 +1,15 @@
 import { Function } from '../function';
-import { Memory } from '../memory';
+import { IMemory } from '../memory';
 import { Message, ModelMessage, SystemMessage, UserMessage } from '../message';
 
-export interface ChatParams {
+export type ChatParams = {
   readonly system?: SystemMessage | UserMessage;
   readonly input: Message;
-  readonly messages?: Memory;
+  readonly messages?: IMemory;
   readonly functions?: Record<string, Function>;
-}
+};
 
-export interface ChatModel {
+export interface IChatModel {
   chat(
     params: ChatParams,
     onChunk?: (chunk: ModelMessage) => void | Promise<void>

packages/ai/src/models/image.ts

@@ -1,8 +1,8 @@
-export interface TextToImageParams {
+export type TextToImageParams = {
   readonly prompt?: string;
   readonly size?: string;
-}
+};
 
-export interface ImageModel {
+export interface IImageModel {
   textToImage?(params?: TextToImageParams): Promise<string>;
 }

packages/ai/src/models/index.ts

@@ -1,8 +1,8 @@
-import { AudioModel } from './audio';
-import { ImageModel } from './image';
-import { ChatModel } from './chat';
+import { IAudioModel } from './audio';
+import { IImageModel } from './image';
+import { IChatModel } from './chat';
 
-export type Model = ChatModel | AudioModel | ImageModel;
+export type Model = IChatModel | IAudioModel | IImageModel;
 
 export * from './chat';
 export * from './audio';

packages/ai/src/prompts/audio.ts

@@ -1,11 +1,11 @@
-import { AudioModel, AudioToTextParams, TextToAudioParams } from '../models';
+import { IAudioModel, AudioToTextParams, TextToAudioParams } from '../models';
 
-export interface AudioPromptOptions {
-  readonly model: AudioModel;
-}
+export type AudioPromptOptions = {
+  readonly model: IAudioModel;
+};
 
 export class AudioPrompt {
-  protected readonly _model: AudioModel;
+  protected readonly _model: IAudioModel;
 
   constructor(options: AudioPromptOptions) {
     this._model = options.model;

packages/ai/src/prompts/chat.ts

@@ -1,25 +1,25 @@
 import { Function, FunctionHandler } from '../function';
 import { LocalMemory } from '../local-memory';
-import { Memory } from '../memory';
+import { IMemory } from '../memory';
 import { ContentPart, Message, SystemMessage, UserMessage } from '../message';
-import { ChatModel } from '../models';
+import { IChatModel } from '../models';
 import { Schema } from '../schema';
-import { Template } from '../template';
+import { ITemplate } from '../template';
 import { StringTemplate } from '../templates';
 
-export interface ChatPromptOptions {
-  readonly model: ChatModel;
-  readonly instructions?: string | Template;
+export type ChatPromptOptions = {
+  readonly model: IChatModel;
+  readonly instructions?: string | ITemplate;
   readonly role?: 'system' | 'user';
-  readonly messages?: Message[] | Memory;
-}
+  readonly messages?: Message[] | IMemory;
+};
 
 export class ChatPrompt {
-  readonly messages: Memory;
+  readonly messages: IMemory;
 
   protected readonly _role: 'system' | 'user';
-  protected readonly _model: ChatModel;
-  protected readonly _template: Template;
+  protected readonly _model: IChatModel;
+  protected readonly _template: ITemplate;
   protected readonly _functions: Record<string, Function> = {};
 
   constructor(options: ChatPromptOptions) {

packages/ai/src/schema.ts

@@ -1,12 +1,12 @@
-interface BaseSchema {
+type BaseSchema = {
   readonly $schema?: string;
   readonly $ref?: string;
   readonly id?: string;
   readonly title?: string;
   readonly description?: string;
   readonly type?: 'object' | 'array' | 'string' | 'number' | 'integer' | 'null' | 'boolean';
   readonly enum?: any[];
-}
+};
 
 export type Schema =
   | StringSchema
@@ -17,43 +17,43 @@ export type Schema =
   | NullSchema
   | AnySchema;
 
-export interface StringSchema extends BaseSchema {
+export type StringSchema = BaseSchema & {
   readonly type: 'string';
   readonly pattern?: string;
   readonly format?: string;
   readonly minLength?: number;
   readonly maxLength?: number;
-}
+};
 
-export interface NumberSchema extends BaseSchema {
+export type NumberSchema = BaseSchema & {
   readonly type: 'number' | 'integer';
   readonly min?: number;
   readonly max?: number;
   readonly multipleOf?: number;
-}
+};
 
-export interface BooleanSchema extends BaseSchema {
+export type BooleanSchema = BaseSchema & {
   readonly type: 'boolean';
-}
+};
 
-export interface ObjectSchema extends BaseSchema {
+export type ObjectSchema = BaseSchema & {
   readonly type: 'object';
   readonly properties?: {
     [key: string]: Schema;
   };
   readonly required?: string[] | boolean;
-}
+};
 
-export interface ArraySchema extends BaseSchema {
+export type ArraySchema = BaseSchema & {
   readonly type: 'array';
   readonly items: Schema | Schema[];
   readonly additionalItems?: Schema | Schema[];
-}
+};
 
-export interface NullSchema extends BaseSchema {
+export type NullSchema = BaseSchema & {
   readonly type: 'null';
-}
+};
 
-export interface AnySchema extends BaseSchema {
+export type AnySchema = BaseSchema & {
   readonly type: undefined;
-}
+};

packages/ai/src/template.ts

@@ -1,3 +1,3 @@
-export interface Template {
+export interface ITemplate {
   render(params?: Record<string, any>): string | Promise<string>;
 }

packages/ai/src/templates/string.ts

@@ -1,6 +1,6 @@
-import { Template } from '../template';
+import { ITemplate } from '../template';
 
-export class StringTemplate implements Template {
+export class StringTemplate implements ITemplate {
   constructor(readonly src?: string) {}
 
   render() {

packages/api/eslint.config.js

@@ -0,0 +1 @@
+module.exports = require('@microsoft/spark.config/eslint.config');

packages/api/package.json

@@ -26,6 +26,8 @@
   ],
   "scripts": {
     "clean": "npx rimraf ./dist",
+    "lint": "npx eslint",
+    "lint:fix": "npx eslint --fix",
     "build": "npx tsup",
     "test": "npx jest"
   },