prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
import * as vscode from "vscode";
import * as fs from "fs";
import path, { resolve } from "path";
import { logger } from "../lib";
import { ABIFragment, IContractQP, IFunctionQP } from "../types";
import { createABIFile, createAddressFile } from "../utils/functions";
import { getAccountInfo } from "./account";
import { Account, CairoAssembly, Contract, ec, Provider } from "starknet";
import { getNetworkProvider } from "./network";
export const loadAllCompiledContract = () => {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const compiledCairoContract = fs
.readdirSync(path_)
.filter((file) => exportPathOfJSONfiles(path_, file));
return compiledCairoContract;
};
const exportPathOfJSONfiles = (path_: string, file: string) => {
const filePath = path.join(path_, file);
if (path.extname(filePath) === ".json") {
const fileData = fs.readFileSync(filePath, {
encoding: "utf-8",
});
if (JSON.parse(fileData).program) return filePath;
if (JSON.parse(fileData).contract_class_version) {
return filePath;
}
}
};
export const setContract = async (context: vscode.ExtensionContext, label: string) => {
if (label === undefined) {
// logger.log("No Contract selected.");
return;
}
void context.workspaceState.update("selectedContract", `${label}.json`);
logger.log(`${label} contract selected`);
createABIFile(`${label}.json`);
createAddressFile(`${label}.json`);
};
export const selectCompiledContract = (context: vscode.ExtensionContext) => {
const contracts = loadAllCompiledContract();
if (contracts === undefined) {
logger.log("No Contract available.");
return;
}
const quickPick = vscode.window.createQuickPick<IContractQP>();
quickPick.items = contracts.map((contract: string) => ({
label: contract.substring(0, contract.length - 5),
}));
quickPick.onDidChangeActive(() => {
quickPick.placeholder = "Select Contract";
});
quickPick.onDidChangeSelection((selection: any) => {
if (selection[0] != null) {
const { label } = selection[0];
setContract(context, label);
quickPick.dispose();
}
});
quickPick.onDidHide(() => {
quickPick.dispose();
});
quickPick.show();
};
export const getContractInfo = (path_: string, fileName: string) => {
try {
const file = fileName.substring(0, fileName.length - 5);
const fileData = fs.readFileSync(
path.join(path_, "starkode", file, `${file}_address.json`),
{ encoding: "utf-8" }
);
const parsedFileData = JSON.parse(fileData);
return parsedFileData;
} catch (error) {
// console.log(error);
return undefined;
}
};
export const getContractABI = (path_: string, fileName: string) => {
try {
const file = fileName.substring(0, fileName.length - 5);
const fileData = fs.readFileSync(
path.join(path_, "starkode", file, `${file}_abi.json`),
{ encoding: "utf-8" }
);
const parsedFileData = JSON.parse(fileData);
return parsedFileData;
} catch (error) {
// console.log(error);
return undefined;
}
};
export const isCairo1Contract = (fileName: string): boolean => {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return false;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const fileData = fs.readFileSync(
path.join(path_, fileName),
{ encoding: "utf-8" }
);
return JSON.parse(fileData).contract_class_version === "0.1.0" ? true : false;
};
export const declareContract = async (context: vscode.ExtensionContext) => {
try {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const provider = getNetworkProvider(context) as Provider;
const selectedContract: string = context.workspaceState.get(
"selectedContract"
) as string;
const selectedAccount = context.workspaceState.get("account") as string;
if (selectedAccount === undefined) {
logger.log("No account selected.");
return;
}
const accountInfo = getAccountInfo(context, selectedAccount);
const account = new Account(
provider,
accountInfo.accountAddress,
accountInfo.privateKey,
"0"
);
const fileName = selectedContract.substring(0, selectedContract.length - 5);
if (
!fs.existsSync(path.join(path_, selectedContract)) ||
!fs.existsSync(path.join(path_, `${fileName}.casm`))
) {
logger.log(`${fileName}.json or ${fileName}.casm must be present.`);
return;
}
const compiledContract = fs.readFileSync(
path.join(path_, selectedContract),
{
encoding: "ascii",
}
);
const casmFileData = fs
.readFileSync(path.join(path_, `${fileName}.casm`))
.toString("ascii");
const casmAssembly: CairoAssembly = JSON.parse(casmFileData);
logger.log("Declaring contract...");
const declareResponse = await account.declareAndDeploy({
contract: compiledContract,
casm: casmAssembly,
});
logger.log(
`declare transaction hash: ${declareResponse.deploy.transaction_hash}`
);
logger.log(`declare classHash: ${declareResponse.deploy.classHash}`);
logger.log("transaction successful");
} catch (error) {
logger.log(`Error while contract declaration: ${error}`);
}
};
export const deployContract = async (context: vscode.ExtensionContext) => {
try {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const provider = getNetworkProvider(context) as Provider;
const selectedContract: string = context.workspaceState.get(
"selectedContract"
) as string;
const selectedAccount = context.workspaceState.get("account") as string;
if (selectedAccount === undefined) {
logger.log("No account selected.");
return;
}
const accountInfo = getAccountInfo(context, selectedAccount);
logger.log("Deploying contract...");
const account = new Account(
provider,
accountInfo.accountAddress,
accountInfo.privateKey,
"0"
);
const contractInfo = getContractInfo(path_, selectedContract);
if (contractInfo.classHash === "") {
logger.log("No classHash available for selected contract.");
return;
}
const deployResponse = await account.deployContract({
classHash: contractInfo.classHash,
});
logger.log(`transaction hash: ${deployResponse.transaction_hash}`);
logger.log("waiting for transaction success...");
await provider.waitForTransaction(deployResponse.transaction_hash);
const { abi: testAbi } = await provider.getClassAt(
deployResponse.contract_address
);
if (testAbi === undefined) {
throw new Error("no abi.");
}
const myTestContract = new Contract(
testAbi,
deployResponse.contract_address,
provider
);
await provider.waitForTransaction(myTestContract.transaction_hash);
logger.log(`contract deployed successfully: ${myTestContract.address}`);
} catch (error) {
logger.log(`Error while contract deployment: ${error}`);
}
};
export const executeContractFunction = async (
context: vscode.ExtensionContext
) => {
try {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const provider = getNetworkProvider(context) as Provider;
const selectedContract: string = context.workspaceState.get(
"selectedContract"
) as string;
const selectedAccount = context.workspaceState.get("account") as string;
if (selectedAccount === undefined) {
logger.log("No account selected.");
return;
}
const accountInfo = getAccountInfo(context, selectedAccount);
const functionABI = await getSelectedFunction(path_, selectedContract);
const contractInfo = getContractInfo(path_, selectedContract);
const params_: Array<any> = functionABI.inputs.map((e) => {
return e.value;
});
const params: Array<any> = params_ !== undefined ? params_ : [];
if (
| functionABI.stateMutability === "view" ||
functionABI.state_mutability === "view"
) { |
const Abi = getContractABI(path_, selectedContract).abi;
const contract = new Contract(Abi, contractInfo.address, provider);
logger.log(`calling function: ${functionABI.name}`);
const functionCall: any = await contract.call(`${functionABI.name}`);
logger.log(`result: ${functionCall.res.toString()}`);
} else {
const Abi = getContractABI(path_, selectedContract).abi;
logger.log(`calling function: ${functionABI.name}`);
const account = new Account(
provider,
accountInfo.accountAddress,
accountInfo.privateKey,
"0"
);
const contract = new Contract(Abi, contractInfo.address, provider);
contract.connect(account);
const result = await contract.invoke(functionABI.name, params);
logger.log(`transaction hash: ${result.transaction_hash}`);
logger.log("waiting for transaction success...");
await provider.waitForTransaction(result.transaction_hash);
logger.log("transaction successfull");
}
} catch (error) {
logger.log(error);
}
};
export const executeContractFunctionFromTreeView = async (
context: vscode.ExtensionContext,
functionabi: ABIFragment
) => {
try {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const provider = getNetworkProvider(context) as Provider;
const selectedContract: string = context.workspaceState.get(
"selectedContract"
) as string;
const selectedAccount = context.workspaceState.get("account") as string;
if (selectedAccount === undefined) {
logger.log("No account selected.");
return;
}
const accountInfo = getAccountInfo(context, selectedAccount);
const functionABI = functionabi;
const contractInfo = getContractInfo(path_, selectedContract);
const params_: Array<any> = functionABI.inputs.map((e) => {
return e.value;
});
const params: Array<any> = params_ !== undefined ? params_ : [];
if (
functionABI.stateMutability === "view" ||
functionABI.state_mutability === "view"
) {
const Abi = getContractABI(path_, selectedContract).abi;
const contract = new Contract(Abi, contractInfo.address, provider);
logger.log(`calling function: ${functionABI.name}`);
const functionCall: any = await contract.call(`${functionABI.name}`);
logger.log(`result: ${functionCall.res.toString()}`);
} else {
const Abi = getContractABI(path_, selectedContract).abi;
logger.log(`calling function: ${functionABI.name}`);
const account = new Account(
provider,
accountInfo.accountAddress,
accountInfo.privateKey,
"0"
);
const contract = new Contract(Abi, contractInfo.address, provider);
contract.connect(account);
const result = await contract.invoke(functionABI.name, params);
logger.log(`transaction hash: ${result.transaction_hash}`);
logger.log("waiting for transaction success...");
await provider.waitForTransaction(result.transaction_hash);
logger.log("transaction successfull");
}
} catch (error) {
logger.log(error);
}
};
const getSelectedFunction = (
path_: string,
selectedContract: string
): Promise<ABIFragment> => {
return new Promise((resolve, reject) => {
try {
const contractInfo: Array<ABIFragment> = getContractABI(
path_,
selectedContract
).abi;
if (contractInfo === undefined) return;
const quickPick = vscode.window.createQuickPick<IFunctionQP>();
quickPick.items = contractInfo.map((account: ABIFragment) => ({
label: account.name,
}));
quickPick.onDidChangeActive(() => {
quickPick.placeholder = "Select Function";
});
quickPick.onDidChangeSelection((selection: any) => {
if (selection[0] != null) {
const { label } = selection[0];
quickPick.dispose();
const functionItem = contractInfo.filter(
(i: ABIFragment) => i.name === label
);
if (functionItem.length === 0)
throw new Error("No function is selected");
resolve(functionItem[0]);
}
});
quickPick.onDidHide(() => {
quickPick.dispose();
});
quickPick.show();
} catch (error) {
reject(error);
}
});
};
| src/config/contract.ts | 7finney-starkode-2fba517 | [
{
"filename": "src/utils/functions.ts",
"retrieved_chunk": " name: func.name,\n inputs: func.inputs.map((e) => {\n return { ...e, value: \"\" };\n }),\n stateMutability: func.stateMutability\n ? func.stateMutability\n : func.state_mutability,\n outputs: func.outputs,\n };\n });",
"score": 32.32227516510035
},
{
"filename": "src/treeView/ABITreeView/AbiTreeDataProvider.ts",
"retrieved_chunk": " const selectedContract: string | undefined = this.context.workspaceState.get(\"selectedContract\") as string;\n const data = getContractABI(path_,selectedContract);\n const inputFunction: Array<ABIFragment> | undefined = selectedContract !== undefined ? data === undefined ? undefined : data.abi :\n [];\n if (inputFunction === undefined) {\n return undefined;\n } \n else {\n if (!element) {\n for (const entry of inputFunction) {",
"score": 23.413139309033348
},
{
"filename": "src/utils/functions.ts",
"retrieved_chunk": " ) {\n const filePath = path.join(path_, file);\n const fileData = fs.readFileSync(filePath, { encoding: \"utf-8\" });\n const isCairo1Contract =\n JSON.parse(fileData).contract_class_version === \"0.1.0\" ? true : false;\n const abi: Array<ABIFragment> = JSON.parse(fileData).abi;\n const abiFunctions = abi.filter((e) => e.type === \"function\");\n const functionsValue = abiFunctions.map((func) => {\n return {\n type: func.type,",
"score": 21.379399001676667
},
{
"filename": "src/extension.ts",
"retrieved_chunk": " treeDataProvider: abiTreeDataProvider,\n });\n const contractName: string | undefined = context.workspaceState.get(\"selectedContract\");\n if (!contractName || contractName === undefined) {\n abiTreeView.message = \"Select a contract and its ABI functions will appear here.\";\n }\n else {\n const contractInfo = getContractInfo(path_, contractName);\n if (contractInfo !== undefined) {\n abiTreeView.description = `${contractName.slice(0, -5)} @ ${contractInfo.address}`;",
"score": 21.27494552701408
},
{
"filename": "src/treeView/ABITreeView/AbiTreeDataProvider.ts",
"retrieved_chunk": " if (entry.type === \"function\") {\n const colapse = (entry.inputs && entry.inputs.length > 0)\n ? TreeItemCollapsibleState.Expanded\n : TreeItemCollapsibleState.None;\n leaves.push(\n new Abi(\n entry.name,\n entry,\n entry.stateMutability === \"view\" || entry.stateMutability === \"external\" ? \"abiReadFunction\" : \"abiFunction\",\n null,",
"score": 20.31126548204103
}
] | typescript | functionABI.stateMutability === "view" ||
functionABI.state_mutability === "view"
) { |
import vscode, { TreeDataProvider, TreeItem, TreeItemCollapsibleState, EventEmitter, Event } from 'vscode';
import { Abi } from './AbiTreeItem';
import { ABIFragment } from '../../types';
import { getContractABI } from '../../config/contract';
import { logger } from '../../lib';
export class AbiTreeDataProvider implements TreeDataProvider<Abi> {
context: vscode.ExtensionContext;
constructor(context: vscode.ExtensionContext) {
this.context = context;
}
getTreeItem(element: Abi): TreeItem {
return element;
}
async getChildren(element?: Abi): Promise<Abi[] | undefined> {
const leaves: Abi[] = [];
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return undefined;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const selectedContract: string | undefined = this.context.workspaceState.get("selectedContract") as string;
const data = getContractABI(path_,selectedContract);
const inputFunction: Array<ABIFragment> | undefined = selectedContract !== undefined ? data === undefined ? undefined : data.abi :
[];
if (inputFunction === undefined) {
return undefined;
}
else {
if (!element) {
for (const entry of inputFunction) {
if (entry.type === "function") {
const colapse = (entry.inputs && entry.inputs.length > 0)
? TreeItemCollapsibleState.Expanded
: TreeItemCollapsibleState.None;
leaves.push(
new Abi(
entry.name,
entry,
entry.stateMutability === "view" || entry.stateMutability === "external" ? "abiReadFunction" : "abiFunction",
null,
[],
colapse
)
);
}
}
| } else if (element.abi.type === "function") { |
const value: any = inputFunction.find((i: any) => i.name === element.abi.name);
for (const input of value.inputs) {
leaves.push(
new Abi(
input.name,
input,
"abiInput",
element,
[],
TreeItemCollapsibleState.None
)
);
}
element.children = leaves;
}
}
return leaves;
}
private _onDidChangeTreeData: EventEmitter<Abi | undefined> = new EventEmitter<Abi | undefined>();
readonly onDidChangeTreeData: Event<Abi | undefined> = this._onDidChangeTreeData.event;
refresh(item?: Abi): void {
this._onDidChangeTreeData.fire(item);
}
}
| src/treeView/ABITreeView/AbiTreeDataProvider.ts | 7finney-starkode-2fba517 | [
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " functionABI.stateMutability === \"view\" ||\n functionABI.state_mutability === \"view\"\n ) {\n const Abi = getContractABI(path_, selectedContract).abi;\n const contract = new Contract(Abi, contractInfo.address, provider);\n logger.log(`calling function: ${functionABI.name}`);\n const functionCall: any = await contract.call(`${functionABI.name}`);\n logger.log(`result: ${functionCall.res.toString()}`);\n } else {\n const Abi = getContractABI(path_, selectedContract).abi;",
"score": 16.862553887147335
},
{
"filename": "src/treeView/ABITreeView/AbiTreeItem.ts",
"retrieved_chunk": " ) {\n super(label, collapsibleState);\n this.contextValue = contextValue;\n if (abi.type === \"function\") {\n this.iconPath = new ThemeIcon(\"symbol-method\");\n } else {\n this.description = abi.type + \" : \" + abi.value;\n this.iconPath = new ThemeIcon(\"symbol-parameter\");\n }\n }",
"score": 13.821077022214334
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " const contractInfo = getContractInfo(path_, selectedContract);\n const params_: Array<any> = functionABI.inputs.map((e) => {\n return e.value;\n });\n const params: Array<any> = params_ !== undefined ? params_ : [];\n if (\n functionABI.stateMutability === \"view\" ||\n functionABI.state_mutability === \"view\"\n ) {\n const Abi = getContractABI(path_, selectedContract).abi;",
"score": 13.766126213133166
},
{
"filename": "src/types/index.ts",
"retrieved_chunk": " value: string;\n}\ninterface outputType {\n name: string;\n type: string;\n}\nexport interface ABIFragment {\n inputs: Array<inputType>;\n name: string;\n stateMutability: string;",
"score": 12.298206135110005
},
{
"filename": "src/utils/functions.ts",
"retrieved_chunk": " name: func.name,\n inputs: func.inputs.map((e) => {\n return { ...e, value: \"\" };\n }),\n stateMutability: func.stateMutability\n ? func.stateMutability\n : func.state_mutability,\n outputs: func.outputs,\n };\n });",
"score": 12.244403057526936
}
] | typescript | } else if (element.abi.type === "function") { |
import vscode, { TreeDataProvider, TreeItem, TreeItemCollapsibleState, EventEmitter, Event } from 'vscode';
import { Abi } from './AbiTreeItem';
import { ABIFragment } from '../../types';
import { getContractABI } from '../../config/contract';
import { logger } from '../../lib';
export class AbiTreeDataProvider implements TreeDataProvider<Abi> {
context: vscode.ExtensionContext;
constructor(context: vscode.ExtensionContext) {
this.context = context;
}
getTreeItem(element: Abi): TreeItem {
return element;
}
async getChildren(element?: Abi): Promise<Abi[] | undefined> {
const leaves: Abi[] = [];
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return undefined;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const selectedContract: string | undefined = this.context.workspaceState.get("selectedContract") as string;
const data = getContractABI(path_,selectedContract);
const inputFunction: Array<ABIFragment> | undefined = selectedContract !== undefined ? data === undefined ? undefined : data.abi :
[];
if (inputFunction === undefined) {
return undefined;
}
else {
if (!element) {
for (const entry of inputFunction) {
if (entry.type === "function") {
const colapse = (entry.inputs && entry.inputs.length > 0)
? TreeItemCollapsibleState.Expanded
: TreeItemCollapsibleState.None;
leaves.push(
new Abi(
entry.name,
entry,
entry.stateMutability === "view" || entry.stateMutability === "external" ? "abiReadFunction" : "abiFunction",
null,
[],
colapse
)
);
}
}
} else if (element.abi.type === "function") {
const value: any = inputFunction.find((i: any) => i.name === element.abi.name);
for (const input of value.inputs) {
leaves.push(
new Abi(
input.name,
input,
"abiInput",
element,
[],
TreeItemCollapsibleState.None
)
);
}
element. | children = leaves; |
}
}
return leaves;
}
private _onDidChangeTreeData: EventEmitter<Abi | undefined> = new EventEmitter<Abi | undefined>();
readonly onDidChangeTreeData: Event<Abi | undefined> = this._onDidChangeTreeData.event;
refresh(item?: Abi): void {
this._onDidChangeTreeData.fire(item);
}
}
| src/treeView/ABITreeView/AbiTreeDataProvider.ts | 7finney-starkode-2fba517 | [
{
"filename": "src/treeView/AccountTreeView/AccountTreeDataProvider.ts",
"retrieved_chunk": " return element;\n }\n async getChildren(element?: Account): Promise<Account[]> {\n const accounts: Array<JSONAccountType> | undefined = getDeployedAccounts(this.context);\n const undeployedAccounts: Array<JSONAccountType> | undefined = await getNotDeployedAccounts(this.context);\n if ((accounts === undefined && undeployedAccounts === undefined)){\n return [];\n } else {\n const leaves = [];\n if (accounts !== undefined) {",
"score": 12.643526143253082
},
{
"filename": "src/treeView/ContractTreeView/ContractTreeDataProvider.ts",
"retrieved_chunk": "import * as vscode from \"vscode\";\nimport { isCairo1Contract, loadAllCompiledContract } from \"../../config/contract\";\nexport class ContractTreeDataProvider implements vscode.TreeDataProvider<Contract> {\n constructor(private workspaceRoot: string | undefined) { }\n getTreeItem(element: Contract): vscode.TreeItem {\n return element;\n }\n async getChildren(element?: Contract): Promise<Contract[]> {\n const contracts = loadAllCompiledContract();\n if (contracts === undefined || contracts.length === 0) {",
"score": 10.960281040781155
},
{
"filename": "src/treeView/AccountTreeView/AccountTreeDataProvider.ts",
"retrieved_chunk": " for (const account of accounts) {\n leaves.push(new Account(\n account.accountAddress.slice(0, 5) + \"...\" + account.accountAddress.slice(-5),\n vscode.TreeItemCollapsibleState.None,\n \"deployedAccount\",\n account,\n \"verified\"\n ));\n }\n }",
"score": 10.797555044513626
},
{
"filename": "src/treeView/ContractTreeView/ContractTreeDataProvider.ts",
"retrieved_chunk": " vscode.window.showInformationMessage(\"No Contracts in workspace\");\n return [];\n } else {\n const leaves = [];\n for (const file of contracts) {\n leaves.push(new Contract(\n file.slice(0, -5),\n vscode.TreeItemCollapsibleState.None,\n \"contract\",\n isCairo1Contract(file) ? \"file-code\" : \"file-text\"",
"score": 10.598650506643928
},
{
"filename": "src/treeView/AccountTreeView/AccountTreeDataProvider.ts",
"retrieved_chunk": " if (undeployedAccounts !== undefined) {\n for (const account of undeployedAccounts) {\n leaves.push(new Account(\n account.accountAddress.slice(0, 5) + \"...\" + account.accountAddress.slice(-5),\n vscode.TreeItemCollapsibleState.None,\n \"undeployedAccount\",\n account,\n \"unverified\"\n ));\n }",
"score": 10.310379465287555
}
] | typescript | children = leaves; |
import * as vscode from "vscode";
import * as fs from "fs";
import path from "path";
import { logger } from "../lib";
import { ABIFragment, JSONAccountType, TIsAccountDeployed } from "../types";
export const createABIFile = (file: string) => {
try {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const fileName = file.substring(0, file.length - 5);
if (!fs.existsSync(path.join(path_, "starkode", fileName))) {
fs.mkdirSync(path.join(path_, "starkode", fileName),{recursive: true});
}
if (
!fs.existsSync(
path.join(path_, "starkode", fileName, `${fileName}_abi.json`)
)
) {
const filePath = path.join(path_, file);
const fileData = fs.readFileSync(filePath, { encoding: "utf-8" });
const isCairo1Contract =
JSON.parse(fileData).contract_class_version === "0.1.0" ? true : false;
const abi: Array<ABIFragment> = JSON.parse(fileData).abi;
const abiFunctions = abi.filter((e) => e.type === "function");
const functionsValue = abiFunctions.map((func) => {
return {
type: func.type,
name: func.name,
inputs: func.inputs.map((e) => {
return { ...e, value: "" };
}),
stateMutability: func.stateMutability
? func.stateMutability
: | func.state_mutability,
outputs: func.outputs,
}; |
});
fs.writeFileSync(
path.join(path_, "starkode", fileName, `${fileName}_abi.json`),
JSON.stringify({ isCairo1: isCairo1Contract, abi: functionsValue }, null, 2)
);
logger.log("ABI file created successfully.");
} else {
logger.log(`${fileName}_abi.json already exist.`);
}
} catch (error) {
logger.log(`Error while writing to file: ${error}`);
}
};
export const createAddressFile = (file: string) => {
try {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const fileName = file.substring(0, file.length - 5);
if (
!fs.existsSync(
path.join(path_, "starkode", fileName, `${fileName}_address.json`)
)
) {
fs.writeFileSync(
path.join(path_, "starkode", fileName, `${fileName}_address.json`),
JSON.stringify({
name: fileName,
address: "",
classHash: "",
}, null, 2)
);
logger.log("Address file created successfully.");
} else {
logger.log(`${fileName}_address.json already exist.`);
}
} catch (error) {
logger.log(`Error while writing to file: ${error}`);
}
};
export const accountDeployStatus = (
accounts: Array<JSONAccountType>,
selectedNetwork: string,
status: boolean
) => {
const networks = ["goerli-alpha", "goerli-alpha-2", "mainnet-alpha"];
let result: Array<JSONAccountType> | undefined;
switch (selectedNetwork) {
case networks[0]: {
result = accounts.filter((e) => e.isDeployed.gAlpha === status);
break;
}
case networks[1]: {
result = accounts.filter((e) => e.isDeployed.gAlpha2 === status);
break;
}
case networks[2]: {
result = accounts.filter((e) => e.isDeployed.mainnet === status);
break;
}
default:
break;
}
return result;
};
| src/utils/functions.ts | 7finney-starkode-2fba517 | [
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " const contractInfo = getContractInfo(path_, selectedContract);\n const params_: Array<any> = functionABI.inputs.map((e) => {\n return e.value;\n });\n const params: Array<any> = params_ !== undefined ? params_ : [];\n if (\n functionABI.stateMutability === \"view\" ||\n functionABI.state_mutability === \"view\"\n ) {\n const Abi = getContractABI(path_, selectedContract).abi;",
"score": 33.808538049951935
},
{
"filename": "src/types/index.ts",
"retrieved_chunk": " value: string;\n}\ninterface outputType {\n name: string;\n type: string;\n}\nexport interface ABIFragment {\n inputs: Array<inputType>;\n name: string;\n stateMutability: string;",
"score": 30.744544838111935
},
{
"filename": "src/treeView/ABITreeView/AbiTreeDataProvider.ts",
"retrieved_chunk": " if (entry.type === \"function\") {\n const colapse = (entry.inputs && entry.inputs.length > 0)\n ? TreeItemCollapsibleState.Expanded\n : TreeItemCollapsibleState.None;\n leaves.push(\n new Abi(\n entry.name,\n entry,\n entry.stateMutability === \"view\" || entry.stateMutability === \"external\" ? \"abiReadFunction\" : \"abiFunction\",\n null,",
"score": 27.322354842527517
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " return;\n }\n const accountInfo = getAccountInfo(context, selectedAccount);\n const functionABI = await getSelectedFunction(path_, selectedContract);\n const contractInfo = getContractInfo(path_, selectedContract);\n const params_: Array<any> = functionABI.inputs.map((e) => {\n return e.value;\n });\n const params: Array<any> = params_ !== undefined ? params_ : [];\n if (",
"score": 21.145289982441998
},
{
"filename": "src/types/index.ts",
"retrieved_chunk": " type: string;\n outputs: Array<outputType>;\n state_mutability?: string;\n}",
"score": 19.244838879076962
}
] | typescript | func.state_mutability,
outputs: func.outputs,
}; |
import * as vscode from "vscode";
import * as fs from "fs";
import path from "path";
import {
createOZAccount,
deleteAccount,
deployAccount,
selectDeployedAccount,
selectNotDeployedAccount,
} from "./config/account";
import {
declareContract,
deployContract,
executeContractFunction,
executeContractFunctionFromTreeView,
getContractInfo,
isCairo1Contract,
loadAllCompiledContract,
selectCompiledContract,
setContract,
} from "./config/contract";
import { updateSelectedNetwork } from "./config/network";
import { logger } from "./lib";
import { ContractTreeDataProvider } from "./treeView/ContractTreeView/ContractTreeDataProvider";
import { editContractAddress, refreshContract } from "./treeView/ContractTreeView/function";
import { Contract as ContractTreeItem } from "./treeView/ContractTreeView/ContractTreeDataProvider";
import { AbiTreeDataProvider } from "./treeView/ABITreeView/AbiTreeDataProvider";
import { editInput } from "./treeView/ABITreeView/functions";
import { AccountTreeDataProvider } from "./treeView/AccountTreeView/AccountTreeDataProvider";
export function activate(context: vscode.ExtensionContext) {
if (vscode.workspace.workspaceFolders === undefined) {
logger.error("Error: Please open your solidity project to vscode");
return;
}
const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;
const watcher = vscode.workspace.createFileSystemWatcher(`${path_}/starkode/**`);
watcher.onDidChange((event: vscode.Uri) => {
const contractName: string | undefined = context.workspaceState.get("selectedContract");
if (contractName === undefined) {
abiTreeView.message = "Select a contract and its ABI functions will appear here.";
} else {
abiTreeView.message = undefined;
const contractInfo = getContractInfo(path_, contractName);
abiTreeView.description = `${contractName.slice(0, -5)} @ ${contractInfo.address}`;
}
| abiTreeDataProvider.refresh(); |
});
// Contract Tree View
const contractTreeDataProvider = new ContractTreeDataProvider(
vscode.workspace.workspaceFolders?.[0].uri.fsPath
);
let contractTreeView = vscode.window.createTreeView("starkode.contracts", {
treeDataProvider: contractTreeDataProvider,
});
// if contract tree view is empty
const contracts = loadAllCompiledContract();
if (contracts === undefined || contracts.length === 0) {
contractTreeView.message = "No contract found. Please compile your contract.";
}
contractTreeView.onDidChangeSelection(event => {
const selectedNodes = event.selection;
if (selectedNodes && selectedNodes.length > 0) {
console.log('Selected nodes:', selectedNodes[0].label);
}
});
// Account Tree View
const accountTreeDataProvider = new AccountTreeDataProvider(
context
);
const accountTreeView = vscode.window.createTreeView("starkode.account", {
treeDataProvider: accountTreeDataProvider,
});
const selectedNetwork: any = context.workspaceState.get("selectedNetwork");
const selectedAccount: string | undefined = context.workspaceState.get("account") as string;
accountTreeView.message = selectedAccount ? `Account : ${selectedAccount.slice(0, 5) + "..." + selectedAccount.slice(-5)} | ${selectedNetwork}` : "Select a deployed account , or create an account and deploy it";
// ABI Tree View
const abiTreeDataProvider = new AbiTreeDataProvider(
context
);
const abiTreeView = vscode.window.createTreeView("starkode.abis", {
treeDataProvider: abiTreeDataProvider,
});
const contractName: string | undefined = context.workspaceState.get("selectedContract");
if (!contractName || contractName === undefined) {
abiTreeView.message = "Select a contract and its ABI functions will appear here.";
}
else {
const contractInfo = getContractInfo(path_, contractName);
if (contractInfo !== undefined) {
abiTreeView.description = `${contractName.slice(0, -5)} @ ${contractInfo.address}`;
} else {
abiTreeView.message = "Select a contract and its ABI functions will appear here.";
}
}
context.subscriptions.push(
vscode.commands.registerCommand("starkode.activate", () => {
try {
if (!fs.existsSync(path.join(path_, "starkode"))) {
fs.mkdirSync(path.join(path_, "starkode"));
}
vscode.window.showInformationMessage("Starkode activated.");
} catch (error) {
console.log(error);
}
}),
vscode.commands.registerCommand("starkode.refreshContracts", async (node: ContractTreeItem) => {
contractTreeView = await refreshContract(node, contractTreeDataProvider);
contractTreeView.message = undefined;
}),
vscode.commands.registerCommand("starkode.useContract", async (node: ContractTreeItem) => {
setContract(context, node.label);
abiTreeView.message = undefined;
const contractInfo = getContractInfo(path_, `${node.label}.json`);
if (contractInfo !== undefined) {
abiTreeView.description = `${node.label} @ ${contractInfo.address}`;
}
abiTreeDataProvider.refresh();
}),
vscode.commands.registerCommand("starkode.useAccount", async (node: any) => {
console.log(node);
if (node.context === "deployedAccount") {
void context.workspaceState.update("account", node.account.accountAddress);
logger.log(`${node.account.accountAddress} selected`);
const selectedNetwork: any = context.workspaceState.get("selectedNetwork");
const selectedAccount = context.workspaceState.get("account") as string;
if (selectedAccount !== undefined) {
accountTreeView.message = `Account : ${selectedAccount.slice(0, 5) + "..." + selectedAccount.slice(-5)} | ${selectedNetwork}`;
}
abiTreeDataProvider.refresh();
} else {
vscode.window.showErrorMessage("Please deploy the account first.");
}
}),
vscode.commands.registerCommand("starkode.createAccountTreeView", async () => {
createOZAccount(context);
accountTreeDataProvider.refresh();
}),
vscode.commands.registerCommand("starkode.selectNetwork", async () => {
await updateSelectedNetwork(context, accountTreeView, accountTreeDataProvider);
}),
vscode.commands.registerCommand("starkode.deployAccountTreeView", async (node: any) => {
void context.workspaceState.update("undeployedAccount", node.account.accountAddress);
logger.log(`${node.account.accountAddress} selected`);
await deployAccount(context, accountTreeDataProvider);
}),
vscode.commands.registerCommand("starkode.copyAccountAddress", async (node: any) => {
vscode.env.clipboard.writeText(node.account.accountAddress);
}),
vscode.commands.registerCommand("starkode.deleteAccount", async (node: any) => {
await deleteAccount(context, node);
accountTreeDataProvider.refresh();
}),
vscode.commands.registerCommand("starkode.editContractAddress", async (node: ContractTreeItem) => {
await editContractAddress(node, context);
}),
vscode.commands.registerCommand("starkode.editInput", async (node: any) => {
const selectedContract: string = context.workspaceState.get(
"selectedContract"
) as string;
await editInput(node, abiTreeDataProvider, selectedContract);
}),
vscode.commands.registerCommand("starkode.deploycontract", async (node: any) => {
const selectedContract: string = context.workspaceState.get(
"selectedContract"
) as string;
if (selectedContract === undefined) {
logger.log("No Contract selected");
return;
}
if (selectedContract.slice(0, -5) !== node.label) {
logger.log("Please select the contract first.");
} else {
if (isCairo1Contract(selectedContract)) {
await vscode.commands.executeCommand("starkode.declareContract");
} else {
await vscode.commands.executeCommand("starkode.deployContract");
}
}
}),
vscode.commands.registerCommand("starkode.selectnetwork", async () => {
await updateSelectedNetwork(context, accountTreeView, accountTreeDataProvider);
}),
vscode.commands.registerCommand("starkode.createaccount", async () => {
createOZAccount(context);
contractTreeDataProvider.refresh();
}),
vscode.commands.registerCommand("starkode.unDeployedAccount", async () => {
selectNotDeployedAccount(context);
}),
vscode.commands.registerCommand("starkode.declareContract", async () => {
await declareContract(context);
}),
vscode.commands.registerCommand("starkode.deployaccount", async () => {
await deployAccount(context, accountTreeDataProvider);
}),
vscode.commands.registerCommand("starkode.selectaccount", async () => {
await selectDeployedAccount(context);
}),
vscode.commands.registerCommand("starkode.selectContract", async () => {
selectCompiledContract(context);
}),
vscode.commands.registerCommand("starkode.deployContract", async () => {
await deployContract(context);
}),
vscode.commands.registerCommand("starkode.callFunction", async () => {
await executeContractFunction(context);
}),
vscode.commands.registerCommand("starkode.callContract", async (node: any) => {
await executeContractFunctionFromTreeView(context, node.abi);
})
);
}
| src/extension.ts | 7finney-starkode-2fba517 | [
{
"filename": "src/config/network.ts",
"retrieved_chunk": " const { label } = selection[0];\n void context.workspaceState.update(\"selectedNetwork\", label);\n quickPick.dispose();\n logger.success(`Selected network is ${label}`);\n const selectedNetwork: any = context.workspaceState.get(\"selectedNetwork\");\n const selectedAccount = context.workspaceState.get(\"account\") as string;\n if (selectedAccount !== undefined) {\n accountTreeView.message = `Account : ${selectedAccount.slice(0, 5) + \"...\" + selectedAccount.slice(-5)} | ${selectedNetwork}`;\n }\n accountTreeDataProvider.refresh();",
"score": 25.85662982000932
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " const account = new Account(\n provider,\n accountInfo.accountAddress,\n accountInfo.privateKey,\n \"0\"\n );\n const contractInfo = getContractInfo(path_, selectedContract);\n if (contractInfo.classHash === \"\") {\n logger.log(\"No classHash available for selected contract.\");\n return;",
"score": 19.14419305371907
},
{
"filename": "src/treeView/ABITreeView/AbiTreeDataProvider.ts",
"retrieved_chunk": " const selectedContract: string | undefined = this.context.workspaceState.get(\"selectedContract\") as string;\n const data = getContractABI(path_,selectedContract);\n const inputFunction: Array<ABIFragment> | undefined = selectedContract !== undefined ? data === undefined ? undefined : data.abi :\n [];\n if (inputFunction === undefined) {\n return undefined;\n } \n else {\n if (!element) {\n for (const entry of inputFunction) {",
"score": 17.488068905866008
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " return;\n }\n const accountInfo = getAccountInfo(context, selectedAccount);\n const functionABI = await getSelectedFunction(path_, selectedContract);\n const contractInfo = getContractInfo(path_, selectedContract);\n const params_: Array<any> = functionABI.inputs.map((e) => {\n return e.value;\n });\n const params: Array<any> = params_ !== undefined ? params_ : [];\n if (",
"score": 16.874764053117097
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " functionABI.stateMutability === \"view\" ||\n functionABI.state_mutability === \"view\"\n ) {\n const Abi = getContractABI(path_, selectedContract).abi;\n const contract = new Contract(Abi, contractInfo.address, provider);\n logger.log(`calling function: ${functionABI.name}`);\n const functionCall: any = await contract.call(`${functionABI.name}`);\n logger.log(`result: ${functionCall.res.toString()}`);\n } else {\n const Abi = getContractABI(path_, selectedContract).abi;",
"score": 16.54998719192283
}
] | typescript | abiTreeDataProvider.refresh(); |
import axios from "axios";
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import { GLOSBE_API } from "../configs";
import {
translateWordGlosbe,
machineTranslation,
getGrammarGlosbe,
translateOxford,
translateCambridge,
} from "../libs";
import { getAudioInfo } from "../utils/getAudio";
import { createManySense, connectTypeOfWord } from "../utils/dbHelper";
import type { Language, LanguagePairs, Source } from "../types";
interface SearchQuery {
word: string;
format: LanguagePairs;
sensesFormat: Language;
}
interface AudioQuery {
source: Source;
}
export async function updatePracticeStatus(
req: Request,
res: Response,
next: NextFunction
) {
try {
const key = req.headers["x-api-key"];
if (
!key ||
typeof key !== "string" ||
key !== `${process.env.CRON_API_KEY}`
) {
return res.status(401).end();
}
const start = new Date(Date.now());
const practices = await prisma.practice.findMany({
where: {
status: "REMEMBERED",
},
select: {
id: true,
numberOfDaysToForget: true,
updatedAt: true,
},
});
await Promise.allSettled(
practices.map(async (e) => {
const diffDate = Math.ceil(
//@ts-ignore
(new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000
);
if (diffDate >= e.numberOfDaysToForget) {
return await prisma.practice.update({
where: { id: e.id },
data: { status: "TEMPORARILY_FORGET" },
});
} else {
// console.log("skip!");
}
})
);
//@ts-ignore
const cost = Math.abs(new Date(Date.now()) - start) / 1000;
return res
.status(200)
.json({ updateCost: `${cost} s`, totalRecords: practices.length });
} catch (error) {
console.error("error:: ", error);
next("500 ERROR");
}
}
export async function search(
req: Request<{}, {}, {}, SearchQuery>,
res: Response,
next: NextFunction
) {
const { format, word } = req.query;
const _format_ = format.split("-");
try {
if (!format || !word) throw new Error("missing query [format, word]");
const resData = await (
await axios.get(
`${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data;
if (resData?.after && Array.isArray(resData?.after)) {
const words = resData?.after.map((e: any) => String(e?.phrase));
return res.status(200).json({ words });
}
return res.status(404).json({ message: "word not found" });
} catch (error) {
console.log("SEARCH ERROR: ", error);
next();
}
}
export async function getWordDetail(
req: Request<
Pick<SearchQuery, "word">,
{},
{},
Pick<SearchQuery, "format"> & AudioQuery
>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { format, source } = req.query;
const _format_ = format.split("-");
if (!word) throw new Error("word missing");
if (!format) throw new Error("format missing");
//@ts-ignore
let resData;
if (format === "en-en") {
if (source === "cambridge") {
resData = await translateCambridge({ word });
} else {
resData = await translateOxford({ word });
}
if (resData) {
return res.status(200).json(resData);
} else {
throw new Error();
}
}
//get word from "cache":
const wordDb = await prisma.word.findUnique({
where: { wordContent: word },
include: {
examples: true,
senses: { include: { example: true, typeOfWord: true } },
less_frequent_senses: true,
similar_phrases: true,
typesOfWord: { select: { type: true } },
},
});
//"cache hit"
if (wordDb) {
return res.status(200).json({
...wordDb,
typesOfWord: wordDb.typesOfWord.map((e) => e.type),
senses: wordDb.senses.map((s) => ({
...s,
typeOfWord: s.typeOfWord?.type,
})),
less_frequent_senses: wordDb.less_frequent_senses.map((e) => e.sense),
});
}
console.time(`time scrape ${word}`);
resData = await translateWordGlosbe({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word,
});
console.timeEnd(`time scrape ${word}`);
if (resData) {
//cache data:
try {
setTimeout(async () => {
const [word] = await prisma.$transaction([
prisma.word.create({
data: {
format,
//@ts-ignore
wordContent: resData.wordContent,
less_frequent_senses:
//@ts-ignore
resData?.less_frequent_senses &&
//@ts-ignore
resData?.less_frequent_senses.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.less_frequent_senses.map((e) => ({
sense: e,
})),
},
}
: undefined,
similar_phrases:
//@ts-ignore
resData?.similar_phrases &&
resData?.similar_phrases.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.similar_phrases.map((e) => ({
en: e.en,
vi: e.vi,
})),
},
}
: undefined,
examples:
//@ts-ignore
resData?.examples && resData.examples.length > 0
? {
createMany: {
//@ts-ignore
data: resData.examples.map((e) => ({
en: e.en,
vi: e.vi,
keyword_en: e?.keyword_en,
keyword_vi: e?.keyword_vi,
})),
},
}
: undefined,
},
}),
prisma.typeOfWord.createMany({
data:
//@ts-ignore
resData.typesOfWord && resData.typesOfWord.length > 0
? //@ts-ignore
resData.typesOfWord.map((e) => ({ type: e }))
: [],
skipDuplicates: true,
}),
]);
//@ts-ignore
if (resData.typesOfWord && resData.typesOfWord.length > 0) {
await Promise.allSettled([
//@ts-ignore
await connectTypeOfWord(resData.typesOfWord, word.wordContent),
//@ts-ignore
await createManySense(resData.senses, word.id),
]);
} else {
//@ts-ignore
await createManySense(resData.senses, word.id);
}
}, 500);
} catch (error) {
console.log("cache ERROR: ", error);
}
return res.status(200).json(resData);
} else {
return res.status(404).json({ message: "word detail not found" });
}
} catch (error) {
console.log("getWordDetail: ", error);
next();
}
}
export async function getGrammar(
req: Request<Pick<SearchQuery, "word">, {}, {}, {}>,
res: Response,
next: NextFunction
) {
const { word } = req.params;
const resData = await getGrammarGlosbe({ word });
if (resData) {
return res.status(200).json({ grammars: resData });
} else {
return res.status(404).json({ message: "grammars not found" });
}
}
export async function getWordDetailByMachine(
req: Request<{}, {}, { sentence: string }, Pick<SearchQuery, "format">>,
res: Response,
next: NextFunction
) {
const { sentence } = req.body;
const { format } = req.query;
const _format_ = format.split("-");
if (!sentence) throw new Error("word missing");
if (!format) throw new Error("format missing");
try {
const resData = await machineTranslation({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word: sentence,
});
if (resData) {
return res.status(200).json(resData);
}
return res
.status(404)
.json({ message: "word detail by machine not found" });
} catch (error) {
console.log("getWordDetailByMachine error: ", error);
next();
}
}
export async function getAudio(
req: Request<Pick<SearchQuery, "word">, {}, {}, AudioQuery>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { source } = req.query;
| const audios = await getAudioInfo({ word, format: "en", source }); |
return res.status(200).json({ audios });
} catch (error) {}
}
| src/controllers/wordController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/middlewares/zodValidate.ts",
"retrieved_chunk": "import { NextFunction, Request, Response } from \"express\";\nimport { AnyZodObject } from \"zod\";\nexport const validate =\n (schema: AnyZodObject) =>\n async (req: Request, res: Response, next: NextFunction) => {\n try {\n await schema.parseAsync({\n body: req.body,\n query: req.query,\n params: req.params,",
"score": 30.784176413413793
},
{
"filename": "src/utils/getAudio.ts",
"retrieved_chunk": "import { getAudioGlosbe, getAudioOxford, getAudioCambridge } from \"../libs\";\nimport type { Source } from \"../types\";\nexport async function getAudioInfo({\n word,\n format,\n source,\n}: {\n word: string;\n format: \"en\" | \"vi\";\n source: Source;",
"score": 29.5593216006763
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " next(\"handleGetTranslationHistory ERROR\");\n }\n}\nexport async function handleDeleteTranslationHistory(\n req: Request<{}, {}, { word: string; deleteOption: string }, {}>,\n res: Response,\n next: NextFunction\n) {\n try {\n const { word, deleteOption } = req.body;",
"score": 25.29109144054711
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": "}\nexport async function handleCreateTranslationHistory(\n req: Request<{}, {}, TranslationHistoryBody, {}>,\n res: Response,\n next: NextFunction\n) {\n const { word, sense, currentLanguage, targetLanguage, translations_history } =\n req.body;\n const { user } = req;\n try {",
"score": 25.027446001525384
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": "export async function handleGetDashboardInfo(\n req: Request<{}, {}, {}, { status: string }>,\n res: Response,\n next: NextFunction\n) {\n const { user } = req;\n const { status } = req.query;\n try {\n const [statusCounting, historyCounting, favoriteCounting, tags] =\n await prisma.$transaction([",
"score": 24.89888810615904
}
] | typescript | const audios = await getAudioInfo({ word, format: "en", source }); |
import axios from "axios";
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import { GLOSBE_API } from "../configs";
import {
translateWordGlosbe,
machineTranslation,
getGrammarGlosbe,
translateOxford,
translateCambridge,
} from "../libs";
import { getAudioInfo } from "../utils/getAudio";
import { createManySense, connectTypeOfWord } from "../utils/dbHelper";
import type { Language, LanguagePairs, Source } from "../types";
interface SearchQuery {
word: string;
format: LanguagePairs;
sensesFormat: Language;
}
interface AudioQuery {
source: Source;
}
export async function updatePracticeStatus(
req: Request,
res: Response,
next: NextFunction
) {
try {
const key = req.headers["x-api-key"];
if (
!key ||
typeof key !== "string" ||
key !== `${process.env.CRON_API_KEY}`
) {
return res.status(401).end();
}
const start = new Date(Date.now());
const practices = await prisma.practice.findMany({
where: {
status: "REMEMBERED",
},
select: {
id: true,
numberOfDaysToForget: true,
updatedAt: true,
},
});
await Promise.allSettled(
practices.map(async (e) => {
const diffDate = Math.ceil(
//@ts-ignore
(new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000
);
if (diffDate >= e.numberOfDaysToForget) {
return await prisma.practice.update({
where: { id: e.id },
data: { status: "TEMPORARILY_FORGET" },
});
} else {
// console.log("skip!");
}
})
);
//@ts-ignore
const cost = Math.abs(new Date(Date.now()) - start) / 1000;
return res
.status(200)
.json({ updateCost: `${cost} s`, totalRecords: practices.length });
} catch (error) {
console.error("error:: ", error);
next("500 ERROR");
}
}
export async function search(
req: Request<{}, {}, {}, SearchQuery>,
res: Response,
next: NextFunction
) {
const { format, word } = req.query;
const _format_ = format.split("-");
try {
if (!format || !word) throw new Error("missing query [format, word]");
const resData = await (
await axios.get(
| `${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data; |
if (resData?.after && Array.isArray(resData?.after)) {
const words = resData?.after.map((e: any) => String(e?.phrase));
return res.status(200).json({ words });
}
return res.status(404).json({ message: "word not found" });
} catch (error) {
console.log("SEARCH ERROR: ", error);
next();
}
}
export async function getWordDetail(
req: Request<
Pick<SearchQuery, "word">,
{},
{},
Pick<SearchQuery, "format"> & AudioQuery
>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { format, source } = req.query;
const _format_ = format.split("-");
if (!word) throw new Error("word missing");
if (!format) throw new Error("format missing");
//@ts-ignore
let resData;
if (format === "en-en") {
if (source === "cambridge") {
resData = await translateCambridge({ word });
} else {
resData = await translateOxford({ word });
}
if (resData) {
return res.status(200).json(resData);
} else {
throw new Error();
}
}
//get word from "cache":
const wordDb = await prisma.word.findUnique({
where: { wordContent: word },
include: {
examples: true,
senses: { include: { example: true, typeOfWord: true } },
less_frequent_senses: true,
similar_phrases: true,
typesOfWord: { select: { type: true } },
},
});
//"cache hit"
if (wordDb) {
return res.status(200).json({
...wordDb,
typesOfWord: wordDb.typesOfWord.map((e) => e.type),
senses: wordDb.senses.map((s) => ({
...s,
typeOfWord: s.typeOfWord?.type,
})),
less_frequent_senses: wordDb.less_frequent_senses.map((e) => e.sense),
});
}
console.time(`time scrape ${word}`);
resData = await translateWordGlosbe({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word,
});
console.timeEnd(`time scrape ${word}`);
if (resData) {
//cache data:
try {
setTimeout(async () => {
const [word] = await prisma.$transaction([
prisma.word.create({
data: {
format,
//@ts-ignore
wordContent: resData.wordContent,
less_frequent_senses:
//@ts-ignore
resData?.less_frequent_senses &&
//@ts-ignore
resData?.less_frequent_senses.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.less_frequent_senses.map((e) => ({
sense: e,
})),
},
}
: undefined,
similar_phrases:
//@ts-ignore
resData?.similar_phrases &&
resData?.similar_phrases.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.similar_phrases.map((e) => ({
en: e.en,
vi: e.vi,
})),
},
}
: undefined,
examples:
//@ts-ignore
resData?.examples && resData.examples.length > 0
? {
createMany: {
//@ts-ignore
data: resData.examples.map((e) => ({
en: e.en,
vi: e.vi,
keyword_en: e?.keyword_en,
keyword_vi: e?.keyword_vi,
})),
},
}
: undefined,
},
}),
prisma.typeOfWord.createMany({
data:
//@ts-ignore
resData.typesOfWord && resData.typesOfWord.length > 0
? //@ts-ignore
resData.typesOfWord.map((e) => ({ type: e }))
: [],
skipDuplicates: true,
}),
]);
//@ts-ignore
if (resData.typesOfWord && resData.typesOfWord.length > 0) {
await Promise.allSettled([
//@ts-ignore
await connectTypeOfWord(resData.typesOfWord, word.wordContent),
//@ts-ignore
await createManySense(resData.senses, word.id),
]);
} else {
//@ts-ignore
await createManySense(resData.senses, word.id);
}
}, 500);
} catch (error) {
console.log("cache ERROR: ", error);
}
return res.status(200).json(resData);
} else {
return res.status(404).json({ message: "word detail not found" });
}
} catch (error) {
console.log("getWordDetail: ", error);
next();
}
}
export async function getGrammar(
req: Request<Pick<SearchQuery, "word">, {}, {}, {}>,
res: Response,
next: NextFunction
) {
const { word } = req.params;
const resData = await getGrammarGlosbe({ word });
if (resData) {
return res.status(200).json({ grammars: resData });
} else {
return res.status(404).json({ message: "grammars not found" });
}
}
export async function getWordDetailByMachine(
req: Request<{}, {}, { sentence: string }, Pick<SearchQuery, "format">>,
res: Response,
next: NextFunction
) {
const { sentence } = req.body;
const { format } = req.query;
const _format_ = format.split("-");
if (!sentence) throw new Error("word missing");
if (!format) throw new Error("format missing");
try {
const resData = await machineTranslation({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word: sentence,
});
if (resData) {
return res.status(200).json(resData);
}
return res
.status(404)
.json({ message: "word detail by machine not found" });
} catch (error) {
console.log("getWordDetailByMachine error: ", error);
next();
}
}
export async function getAudio(
req: Request<Pick<SearchQuery, "word">, {}, {}, AudioQuery>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { source } = req.query;
const audios = await getAudioInfo({ word, format: "en", source });
return res.status(200).json({ audios });
} catch (error) {}
}
| src/controllers/wordController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": "}: {\n format: Language;\n word: string;\n}) {\n let raw_phonetics;\n let phonetics;\n try {\n raw_phonetics = await (\n await axios.get(`${GLOSBE_URL}/api/audios/${format}/${word}`)\n ).data;",
"score": 36.17901954693315
},
{
"filename": "src/utils/getAudio.ts",
"retrieved_chunk": "import { getAudioGlosbe, getAudioOxford, getAudioCambridge } from \"../libs\";\nimport type { Source } from \"../types\";\nexport async function getAudioInfo({\n word,\n format,\n source,\n}: {\n word: string;\n format: \"en\" | \"vi\";\n source: Source;",
"score": 25.418856918098882
},
{
"filename": "src/utils/getAudio.ts",
"retrieved_chunk": "}) {\n switch (source) {\n case \"glosbe\":\n return await getAudioGlosbe({ format, word });\n case \"oxford\":\n return await getAudioOxford({ word });\n case \"cambridge\":\n return await getAudioCambridge({ word });\n }\n}",
"score": 23.255942430528183
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " } catch (error) {\n console.error(\"machineTranslation error: \", error);\n return null;\n }\n}\nexport async function getGrammarGlosbe({ word }: { word: string }) {\n // https://vi.glosbe.com/en/vi/straightforward/fragment/details?phraseIndex=0&translationIndex=-1\n try {\n const rawData = await (\n await axios.get(",
"score": 21.84001927170104
},
{
"filename": "src/libs/cambridge.dictionary.ts",
"retrieved_chunk": " await axios.get(\n `${CAMBRIDGE_DICTIONARY_URL}/vi/dictionary/english/${word}`\n )\n ).data;\n const document = parse(rawData);\n const wordContent = document.querySelector(\n \"#page-content > div.page > div:nth-child(1) > div.link > div > div.di-body > div > div > div:nth-child(1) > div.pos-header.dpos-h > div.di-title > span > span\"\n )?.textContent;\n if (!wordContent) throw new Error();\n const typesOfWord = document",
"score": 20.607130322031093
}
] | typescript | `${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data; |
import axios from "axios";
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import { GLOSBE_API } from "../configs";
import {
translateWordGlosbe,
machineTranslation,
getGrammarGlosbe,
translateOxford,
translateCambridge,
} from "../libs";
import { getAudioInfo } from "../utils/getAudio";
import { createManySense, connectTypeOfWord } from "../utils/dbHelper";
import type { Language, LanguagePairs, Source } from "../types";
interface SearchQuery {
word: string;
format: LanguagePairs;
sensesFormat: Language;
}
interface AudioQuery {
source: Source;
}
export async function updatePracticeStatus(
req: Request,
res: Response,
next: NextFunction
) {
try {
const key = req.headers["x-api-key"];
if (
!key ||
typeof key !== "string" ||
key !== `${process.env.CRON_API_KEY}`
) {
return res.status(401).end();
}
const start = new Date(Date.now());
const practices = await prisma.practice.findMany({
where: {
status: "REMEMBERED",
},
select: {
id: true,
numberOfDaysToForget: true,
updatedAt: true,
},
});
await Promise.allSettled(
practices.map(async (e) => {
const diffDate = Math.ceil(
//@ts-ignore
(new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000
);
if (diffDate >= e.numberOfDaysToForget) {
return await prisma.practice.update({
where: { id: e.id },
data: { status: "TEMPORARILY_FORGET" },
});
} else {
// console.log("skip!");
}
})
);
//@ts-ignore
const cost = Math.abs(new Date(Date.now()) - start) / 1000;
return res
.status(200)
.json({ updateCost: `${cost} s`, totalRecords: practices.length });
} catch (error) {
console.error("error:: ", error);
next("500 ERROR");
}
}
export async function search(
req: Request<{}, {}, {}, SearchQuery>,
res: Response,
next: NextFunction
) {
const { format, word } = req.query;
const _format_ = format.split("-");
try {
if (!format || !word) throw new Error("missing query [format, word]");
const resData = await (
await axios.get(
`${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data;
if (resData?.after && Array.isArray(resData?.after)) {
const words = resData?.after.map((e: any) => String(e?.phrase));
return res.status(200).json({ words });
}
return res.status(404).json({ message: "word not found" });
} catch (error) {
console.log("SEARCH ERROR: ", error);
next();
}
}
export async function getWordDetail(
req: Request<
Pick<SearchQuery, "word">,
{},
{},
Pick<SearchQuery, "format"> & AudioQuery
>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { format, source } = req.query;
const _format_ = format.split("-");
if (!word) throw new Error("word missing");
if (!format) throw new Error("format missing");
//@ts-ignore
let resData;
if (format === "en-en") {
if (source === "cambridge") {
resData = await translateCambridge({ word });
} else {
resData = await translateOxford({ word });
}
if (resData) {
return res.status(200).json(resData);
} else {
throw new Error();
}
}
//get word from "cache":
const wordDb = await prisma.word.findUnique({
where: { wordContent: word },
include: {
examples: true,
senses: { include: { example: true, typeOfWord: true } },
less_frequent_senses: true,
similar_phrases: true,
typesOfWord: { select: { type: true } },
},
});
//"cache hit"
if (wordDb) {
return res.status(200).json({
...wordDb,
typesOfWord: wordDb.typesOfWord.map((e) => e.type),
senses: | wordDb.senses.map((s) => ({ |
...s,
typeOfWord: s.typeOfWord?.type,
})),
less_frequent_senses: wordDb.less_frequent_senses.map((e) => e.sense),
});
}
console.time(`time scrape ${word}`);
resData = await translateWordGlosbe({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word,
});
console.timeEnd(`time scrape ${word}`);
if (resData) {
//cache data:
try {
setTimeout(async () => {
const [word] = await prisma.$transaction([
prisma.word.create({
data: {
format,
//@ts-ignore
wordContent: resData.wordContent,
less_frequent_senses:
//@ts-ignore
resData?.less_frequent_senses &&
//@ts-ignore
resData?.less_frequent_senses.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.less_frequent_senses.map((e) => ({
sense: e,
})),
},
}
: undefined,
similar_phrases:
//@ts-ignore
resData?.similar_phrases &&
resData?.similar_phrases.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.similar_phrases.map((e) => ({
en: e.en,
vi: e.vi,
})),
},
}
: undefined,
examples:
//@ts-ignore
resData?.examples && resData.examples.length > 0
? {
createMany: {
//@ts-ignore
data: resData.examples.map((e) => ({
en: e.en,
vi: e.vi,
keyword_en: e?.keyword_en,
keyword_vi: e?.keyword_vi,
})),
},
}
: undefined,
},
}),
prisma.typeOfWord.createMany({
data:
//@ts-ignore
resData.typesOfWord && resData.typesOfWord.length > 0
? //@ts-ignore
resData.typesOfWord.map((e) => ({ type: e }))
: [],
skipDuplicates: true,
}),
]);
//@ts-ignore
if (resData.typesOfWord && resData.typesOfWord.length > 0) {
await Promise.allSettled([
//@ts-ignore
await connectTypeOfWord(resData.typesOfWord, word.wordContent),
//@ts-ignore
await createManySense(resData.senses, word.id),
]);
} else {
//@ts-ignore
await createManySense(resData.senses, word.id);
}
}, 500);
} catch (error) {
console.log("cache ERROR: ", error);
}
return res.status(200).json(resData);
} else {
return res.status(404).json({ message: "word detail not found" });
}
} catch (error) {
console.log("getWordDetail: ", error);
next();
}
}
export async function getGrammar(
req: Request<Pick<SearchQuery, "word">, {}, {}, {}>,
res: Response,
next: NextFunction
) {
const { word } = req.params;
const resData = await getGrammarGlosbe({ word });
if (resData) {
return res.status(200).json({ grammars: resData });
} else {
return res.status(404).json({ message: "grammars not found" });
}
}
export async function getWordDetailByMachine(
req: Request<{}, {}, { sentence: string }, Pick<SearchQuery, "format">>,
res: Response,
next: NextFunction
) {
const { sentence } = req.body;
const { format } = req.query;
const _format_ = format.split("-");
if (!sentence) throw new Error("word missing");
if (!format) throw new Error("format missing");
try {
const resData = await machineTranslation({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word: sentence,
});
if (resData) {
return res.status(200).json(resData);
}
return res
.status(404)
.json({ message: "word detail by machine not found" });
} catch (error) {
console.log("getWordDetailByMachine error: ", error);
next();
}
}
export async function getAudio(
req: Request<Pick<SearchQuery, "word">, {}, {}, AudioQuery>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { source } = req.query;
const audios = await getAudioInfo({ word, format: "en", source });
return res.status(200).json({ audios });
} catch (error) {}
}
| src/controllers/wordController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/utils/dbHelper.ts",
"retrieved_chunk": "export async function connectTypeOfWord(typesOfWord, word) {\n await prisma.$transaction(\n typesOfWord.map((type) => {\n return prisma.word.update({\n where: { wordContent: word },\n data: {\n typesOfWord: { connect: { type } },\n },\n });\n })",
"score": 27.538462295405218
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " if (typesOfWord && wordContent && senses) {\n return {\n wordContent,\n typesOfWord,\n senses,\n less_frequent_senses,\n similar_phrases,\n examples,\n };\n } else {",
"score": 27.52241165345393
},
{
"filename": "src/libs/oxford.dictionary.ts",
"retrieved_chunk": " });\n return {\n wordContent,\n typesOfWord: [typesOfWord],\n senses,\n };\n } catch (error) {\n console.log(\"translateOxford error: \", error);\n return null;\n }",
"score": 22.534487486500428
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " const typesOfWord = document\n .querySelectorAll(\n \"#phraseDetails_activator-0 > div.text-xl.text-gray-900.px-1.pb-1 > span.text-xxs.text-gray-500 > span\"\n )\n .map((e) => e?.textContent);\n const senses = document\n .querySelectorAll(\n \"#dictionary-content > article > div > div > section.bg-white.px-1 > div.pl-1 > div > ul.pr-1 > li\"\n )\n .map((li) => {",
"score": 21.79835799212052
},
{
"filename": "src/utils/dbHelper.ts",
"retrieved_chunk": " category: e?.category ? e?.category : undefined,\n example: e?.example\n ? { create: { en: e.example.en, vi: e.example.vi } }\n : undefined,\n typeOfWord: e?.typeOfWord\n ? {\n connectOrCreate: {\n create: { type: e.typeOfWord },\n where: { type: e.typeOfWord },\n },",
"score": 19.683271395898895
}
] | typescript | wordDb.senses.map((s) => ({ |
import { CAMBRIDGE_DICTIONARY_URL } from "../configs";
import { parse } from "node-html-parser";
import axios from "axios";
import { normalizeString } from "../utils/string";
export async function getAudioCambridge({ word }: { word: string }) {
let raw_phonetics;
let phonetics;
try {
raw_phonetics = await (
await axios.get(
`${CAMBRIDGE_DICTIONARY_URL}/vi/dictionary/english/${word}`
)
).data;
const document = parse(raw_phonetics);
const uk_audio =
String(CAMBRIDGE_DICTIONARY_URL) +
document.querySelector("#audio1 source")?.getAttribute("src");
const uk_phonetic = document.querySelector(
"#page-content > div.page > div:nth-child(1) > div.link > div > div.di-body > div > div > div:nth-child(1) > div.pos-header.dpos-h > span.uk.dpron-i > span.pron.dpron"
)?.textContent;
const raw_us_audio = document
.querySelector("#audio2 source")
?.getAttribute("src");
if (!raw_us_audio) return null;
const us_audio = String(CAMBRIDGE_DICTIONARY_URL) + raw_us_audio;
const us_phonetic = document.querySelector(
"#page-content > div.page > div:nth-child(1) > div.link > div > div.di-body > div > div > div:nth-child(1) > div.pos-header.dpos-h > span.us.dpron-i > span.pron.dpron"
)?.textContent;
phonetics = [
{ phrase: uk_phonetic, author: "Cambridge_English", url: uk_audio },
{ phrase: us_phonetic, author: "Cambridge_American", url: us_audio },
];
} catch (error) {
console.error("get audio cambridge error: ", error);
}
return phonetics;
}
export async function translateCambridge({ word }: { word: string }) {
try {
const rawData = await (
await axios.get(
`${CAMBRIDGE_DICTIONARY_URL}/vi/dictionary/english/${word}`
)
).data;
const document = parse(rawData);
const wordContent = document.querySelector(
"#page-content > div.page > div:nth-child(1) > div.link > div > div.di-body > div > div > div:nth-child(1) > div.pos-header.dpos-h > div.di-title > span > span"
)?.textContent;
if (!wordContent) throw new Error();
const typesOfWord = document
.querySelectorAll(".pr.entry-body__el .pos.dpos")
.map((span) => span?.textContent);
const senses = document
.querySelectorAll(".pr.entry-body__el")
.map((container) => {
const typeOfWord = container.querySelector(".pos.dpos")?.textContent;
const sense = container.querySelector(".def.ddef_d.db")?.textContent;
const examples = container
.querySelectorAll(".examp.dexamp")
.map((div) => {
| return normalizeString(String(div?.textContent)); |
});
return { typeOfWord, sense, examples };
});
return { wordContent, typesOfWord: [...new Set(typesOfWord)], senses };
} catch (error) {
console.log("translateCambridge error ", error);
return null;
}
}
| src/libs/cambridge.dictionary.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/libs/oxford.dictionary.ts",
"retrieved_chunk": " ).data;\n const document = parse(rawData);\n const wordContent = document.querySelector(`#${word}_h_1`)?.textContent;\n if (!wordContent) throw new Error();\n const typesOfWord = document.querySelector(`span.pos`)?.textContent;\n const senses = document.querySelectorAll(\"span.def\").map((span, index) => {\n const examples = document\n .querySelectorAll(`#${word}_sng_${index + 1} > ul > li`)\n .map((li) => li?.textContent);\n return { sense: span?.textContent, typeOfWord: typesOfWord, examples };",
"score": 67.133899756712
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " example,\n };\n });\n const less_frequent_senses = document\n .querySelectorAll(\n \"#less-frequent-translations-container-0 > li > div:nth-child(2) > ul > li\"\n )\n .map((li) => li?.textContent);\n const similar_phrases = document\n .querySelectorAll(\"#simmilar-phrases > ul > li\")",
"score": 53.30154246091286
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " const sense = li.querySelector(\"h3\")?.textContent;\n const typeOfWord = li.querySelector(\n \"span.text-xxs.text-gray-500 > span\"\n )?.textContent;\n const topic = li.querySelector(\"div.py-1 > p > span\");\n // check if word has example or not:\n const example = li.querySelector(\"div > p.dir-aware-pr-1\")\n ? {\n [language_1]: normalizeString(\n String(li.querySelector(\"div > p.dir-aware-pr-1\")?.textContent)",
"score": 52.27778824629958
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " .map((li) => {\n return {\n [language_1]: li.querySelector(\"a\")?.textContent,\n [language_2]: normalizeString(\n String(li.querySelector(\".dir-aware-pl-2\")?.textContent)\n ),\n };\n });\n const examples = document\n .querySelectorAll(",
"score": 51.92271462157419
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " const typesOfWord = document\n .querySelectorAll(\n \"#phraseDetails_activator-0 > div.text-xl.text-gray-900.px-1.pb-1 > span.text-xxs.text-gray-500 > span\"\n )\n .map((e) => e?.textContent);\n const senses = document\n .querySelectorAll(\n \"#dictionary-content > article > div > div > section.bg-white.px-1 > div.pl-1 > div > ul.pr-1 > li\"\n )\n .map((li) => {",
"score": 47.28749337040609
}
] | typescript | return normalizeString(String(div?.textContent)); |
import axios from "axios";
import { GLOSBE_URL, GLOSBE_TRANSLATOR_API } from "../configs";
import type { Language } from "../types";
import { parse } from "node-html-parser";
import { normalizeString } from "../utils/string";
import { translate } from "@vitalets/google-translate-api";
import { googleTranslate } from "./google.dictionary";
export async function getAudioGlosbe({
format,
word,
}: {
format: Language;
word: string;
}) {
let raw_phonetics;
let phonetics;
try {
raw_phonetics = await (
await axios.get(`${GLOSBE_URL}/api/audios/${format}/${word}`)
).data;
phonetics = raw_phonetics?.phraseAudioCarrier?.audioEntries?.map(
(entry: any) => {
return {
phrase: entry.phrase,
author: entry.author.name,
url: `${GLOSBE_URL}/fb_aud/mp3/${entry.url.mp3}`,
};
}
);
} catch (error) {
console.error("get audio glosbe error: ", error);
}
return phonetics;
}
export async function translateWordGlosbe({
language_1,
language_2,
word,
}: {
language_1: Language;
language_2: Language;
word: string;
}) {
try {
const raw = await (
await axios.get(`${GLOSBE_URL}/${language_1}/${language_2}/${word}`)
).data;
//@ts-ignore
const document = parse(raw);
const wordContent = document.querySelector("span.break-words")?.textContent;
const typesOfWord = document
.querySelectorAll(
"#phraseDetails_activator-0 > div.text-xl.text-gray-900.px-1.pb-1 > span.text-xxs.text-gray-500 > span"
)
.map((e) => e?.textContent);
const senses = document
.querySelectorAll(
"#dictionary-content > article > div > div > section.bg-white.px-1 > div.pl-1 > div > ul.pr-1 > li"
)
.map((li) => {
const sense = li.querySelector("h3")?.textContent;
const typeOfWord = li.querySelector(
"span.text-xxs.text-gray-500 > span"
)?.textContent;
const topic = li.querySelector("div.py-1 > p > span");
// check if word has example or not:
const example = li.querySelector("div > p.dir-aware-pr-1")
? {
[language_1]: normalizeString(
String(li.querySelector("div > p.dir-aware-pr-1")?.textContent)
),
[language_2]: normalizeString(
String(li.querySelector("div > p.px-1.ml-2")?.textContent)
),
}
: undefined;
return {
sense,
typeOfWord,
category: topic ? normalizeString(String(topic).trim()) : undefined,
example,
};
});
const less_frequent_senses = document
.querySelectorAll(
"#less-frequent-translations-container-0 > li > div:nth-child(2) > ul > li"
)
.map((li) => li?.textContent);
const similar_phrases = document
.querySelectorAll("#simmilar-phrases > ul > li")
.map((li) => {
return {
[language_1]: li.querySelector("a")?.textContent,
[language_2]: normalizeString(
String(li.querySelector(".dir-aware-pl-2")?.textContent)
),
};
});
const examples = document
.querySelectorAll(
"#tmem_first_examples > div.px-1.text-sm.text-gray-900.break-words > div > div.py-2.flex"
)
.map((div) => {
return {
[language_1]: normalizeString(
String(div.querySelector("div:nth-child(1)")?.textContent)
),
[`keyword_${language_1}`]: div.querySelector(
"div:nth-child(1) .keyword"
)
? normalizeString(
String(
div.querySelector("div:nth-child(1) .keyword")?.textContent
)
)
: undefined,
[language_2]: normalizeString(
String(div.querySelector("div:nth-child(2)")?.textContent)
),
[`keyword_${language_2}`]: div.querySelector(
"div:nth-child(2) .keyword"
)
? normalizeString(
String(
div.querySelector("div:nth-child(2) .keyword")?.textContent
)
)
: undefined,
};
});
if (typesOfWord && wordContent && senses) {
return {
wordContent,
typesOfWord,
senses,
less_frequent_senses,
similar_phrases,
examples,
};
} else {
return null;
}
} catch (error) {
console.log("glosbe translate error: ", error);
return null;
}
}
export async function machineTranslation({
language_1,
language_2,
word,
}: {
language_1: Language;
language_2: Language;
word: string;
}) {
try {
const [google] = await Promise.allSettled([
// (
// await axios.post(
// `${GLOSBE_TRANSLATOR_API}/translateByLangWithScore?sourceLang=${language_1}&targetLang=${language_2}`,
// word,
// {
// headers: {
// "Content-Type": "text/plain;charset=UTF-8",
// },
// }
// )
// ).data,
| await googleTranslate({ |
text: word,
source_language: language_1,
target_language: language_2,
}),
]);
if (google.status === "fulfilled") {
return { google: google.value };
} else {
return null;
}
} catch (error) {
console.error("machineTranslation error: ", error);
return null;
}
}
export async function getGrammarGlosbe({ word }: { word: string }) {
// https://vi.glosbe.com/en/vi/straightforward/fragment/details?phraseIndex=0&translationIndex=-1
try {
const rawData = await (
await axios.get(
`${GLOSBE_URL}/en/vi/${word}/fragment/details?phraseIndex=0&translationIndex=-1`
)
).data;
const document = parse(rawData);
const grammars = document
.querySelectorAll("#grammar_0_-1 > ul > li")
.map((li) => {
return li?.textContent;
});
return grammars;
} catch (error) {
console.log("getGrammarGlosbe error: ", error);
return null;
}
}
| src/libs/glosbe.dictionary.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " console.time(`time scrape ${word}`);\n resData = await translateWordGlosbe({\n language_1: _format_[0] as Language,\n language_2: _format_[1] as Language,\n word,\n });\n console.timeEnd(`time scrape ${word}`);\n if (resData) {\n //cache data:\n try {",
"score": 11.758461318052204
},
{
"filename": "src/libs/google.dictionary.ts",
"retrieved_chunk": "import axios from \"axios\";\nimport { translate } from \"@vitalets/google-translate-api\";\nexport async function googleTranslate({\n text,\n target_language,\n source_language,\n}: {\n text: string;\n target_language: string;\n source_language: string;",
"score": 10.303892309458893
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " try {\n const resData = await machineTranslation({\n language_1: _format_[0] as Language,\n language_2: _format_[1] as Language,\n word: sentence,\n });\n if (resData) {\n return res.status(200).json(resData);\n }\n return res",
"score": 9.713699689343441
},
{
"filename": "src/libs/google.dictionary.ts",
"retrieved_chunk": " const encodedParams = new URLSearchParams();\n encodedParams.append(\"source_language\", source_language);\n encodedParams.append(\"target_language\", target_language);\n encodedParams.append(\"text\", text);\n const options = {\n method: \"POST\",\n url: `${process.env.TRANSLATE_URL}`,\n headers: {\n \"content-type\": \"application/x-www-form-urlencoded\",\n \"X-RapidAPI-Key\": `${process.env.RAPID_API_KEY}`,",
"score": 7.798052431011312
},
{
"filename": "src/libs/google.dictionary.ts",
"retrieved_chunk": "}) {\n try {\n const { text: textTranslated } = await translate(text, {\n to: target_language,\n });\n return textTranslated;\n } catch (error) {\n try {\n //fallback rate limit:\n console.log(\"-- RATE LIMIT AND CALL RAPID API HOST FALLBACK --\");",
"score": 6.2682759823778165
}
] | typescript | await googleTranslate({ |
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import type { PracticeStatus } from "@prisma/client";
export async function handleGetUserInfo(
req: Request,
res: Response,
next: NextFunction
) {
try {
return res.status(200).json(req.user);
} catch (error) {
console.error("handleGetUserInfo ERROR: ", error);
return res.status(500).json("ERROR");
}
}
interface TranslationHistoryBody {
word: string;
sense: string;
currentLanguage: string;
targetLanguage: string;
translations_history: TranslationHistoryBody[];
}
export async function handleUpdatePracticeStatus(
req: Request<{}, {}, { status: PracticeStatus; wordContent: string }>,
res: Response,
next: NextFunction
) {
const { user } = req;
let { status, wordContent } = req.body;
try {
const practiceOwner = await prisma.practice.findUnique({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent,
},
},
});
const forgottenFrequencyOwner = practiceOwner?.forgottenFrequency
? practiceOwner?.forgottenFrequency
: 0;
const practice = await prisma.practice.update({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent,
},
},
select: {
status: true,
updatedAt: true,
},
data: {
status,
forgottenFrequency:
status === "REMEMBERED" ? 0 : forgottenFrequencyOwner + 1,
},
});
return res.status(200).json(practice);
} catch (error) {
console.error(`handleGetWordsPreview: ${error}`);
next("handleGetWordsPreview ERROR");
}
}
export async function handleGetWordsPractice(
req: Request<
{},
{},
{},
{ status: string; tags: string; page?: number; limit?: number }
>,
res: Response,
next: NextFunction
) {
const { user } = req;
let { status, page, tags, limit } = req.query;
if (!page) page = 1;
if (!limit) limit = 20;
const _status_ = status.split("+");
const _tags_ = tags.split("+");
const orConditions = [
..._status_.map((e) => ({ status: e })),
..._tags_.map((e) => ({ tag: e })),
];
try {
const [practices, totalRecords] = await prisma.$transaction([
prisma.practice.findMany({
where: {
//@ts-ignore
userId: user.id,
tag: tags ? { in: _tags_ } : undefined,
//@ts-ignore
status: status ? { in: _status_ } : undefined,
},
select: {
id: true,
status: true,
tag: true,
word: {
select: {
less_frequent_senses: { select: { sense: true } },
format: true,
wordContent: true,
senses: true,
},
},
},
take: Number(limit),
skip: (Number(page) - 1) * limit,
orderBy: {
createdAt: "desc",
},
}),
prisma.practice.count({
where: {
//@ts-ignore
userId: user.id,
tag: { in: _tags_ },
//@ts-ignore
status: { in: _status_ },
},
}),
]);
return res
.status(200)
.json({ practices, totalPages: Math.ceil(totalRecords / limit) });
} catch (error) {
console.error(`handleGetWordsPreview: ${error}`);
next("handleGetWordsPreview ERROR");
}
}
export async function handleGetWordsPreview(
req: Request<
{},
{},
{},
{ status: string; tag?: string; page?: number; limit?: number }
>,
res: Response,
next: NextFunction
) {
const { user } = req;
let { status, page, tag, limit } = req.query;
if (!page) page = 1;
if (!limit) limit = 18;
try {
const [words, totalRecords] = await prisma.$transaction([
prisma.practice.findMany({
where: {
//@ts-ignore
userId: user.id,
//@ts-ignore
status,
tag,
},
select: {
word: {
select: {
format: true,
wordContent: true,
senses: { select: { sense: true } },
},
},
},
take: Number(limit),
skip: (Number(page) - 1) * limit,
orderBy: {
createdAt: 'desc'
}
}),
prisma.practice.count({
where: {
//@ts-ignore
userId: user.id,
//@ts-ignore
status,
tag,
},
}),
]);
return res
.status(200)
.json({ words, totalPages: Math.ceil(totalRecords / limit) });
} catch (error) {
console.error(`handleGetWordsPreview: ${error}`);
next("handleGetWordsPreview ERROR");
}
}
export async function handleGetDashboardInfo(
req: Request<{}, {}, {}, { status: string }>,
res: Response,
next: NextFunction
) {
const { user } = req;
const { status } = req.query;
try {
const [statusCounting, historyCounting, favoriteCounting, tags] =
await prisma.$transaction([
prisma.practice.count({
//@ts-ignore
where: { userId: user.id, status },
}),
| prisma.translationHistory.count({ |
//@ts-ignore
where: { userId: user.id },
}),
prisma.practice.count({
//@ts-ignore
where: { userId: user.id },
}),
prisma.practice.findMany({
//@ts-ignore
where: { userId: user.id },
distinct: ["tag"],
select: { tag: true },
}),
]);
return res
.status(200)
.json({ statusCounting, historyCounting, favoriteCounting, tags });
} catch (error) {
console.error(`handleGetDashboardInfo: ${error}`);
next("handleGetDashboardInfo ERROR");
}
}
export async function handleDeleteFavorite(
req: Request<{}, {}, { word: string }>,
res: Response,
next: NextFunction
) {
const { word } = req.body;
const { user } = req;
try {
const deletedStatus = await prisma.practice.delete({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent: word,
},
},
});
return res.status(200).json(deletedStatus);
} catch (error) {
console.error(`handleCreateFavorite: ${error}`);
next("handleCreateFavorite ERROR");
}
}
export async function handleCreateFavorite(
req: Request<
{},
{},
{ word: string; tag?: string; numberOfDaysToForget?: number }
>,
res: Response,
next: NextFunction
) {
const { word, numberOfDaysToForget, tag } = req.body;
const { user } = req;
try {
const practiceWord = await prisma.practice.upsert({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent: word,
},
},
create: {
word: { connect: { wordContent: word } },
//@ts-ignore
user: { connect: { id: user.id } },
numberOfDaysToForget,
tag,
},
update: {},
});
return res.status(201).json(practiceWord);
} catch (error) {
console.error(`handleCreateFavorite: ${error}`);
next("handleCreateFavorite ERROR");
}
}
export async function handleGetInfoFavorite(
req: Request<{}, {}, {}, { word: string }>,
res: Response,
next: NextFunction
) {
const { word } = req.query;
const { user } = req;
try {
const practiceWord = await prisma.practice.findUnique({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent: word,
},
},
select: {
createdAt: true,
},
});
return res.status(200).json(practiceWord);
} catch (error) {
console.error(`handleGetInfoFavorite: ${error}`);
next("handleGetInfoFavorite ERROR");
}
}
export async function handleCreateTranslationHistory(
req: Request<{}, {}, TranslationHistoryBody, {}>,
res: Response,
next: NextFunction
) {
const { word, sense, currentLanguage, targetLanguage, translations_history } =
req.body;
const { user } = req;
try {
//multiple create:
if (translations_history && translations_history.length > 0) {
const tHistory = await prisma.translationHistory.createMany({
data: translations_history.map((e) => ({
word: e.word,
sense: e.sense,
currentLanguage: e.currentLanguage,
targetLanguage: e.targetLanguage,
//@ts-ignore
userId: user.id,
})),
skipDuplicates: true,
});
return res.status(201).json(tHistory);
}
//single create:
const tHistory = await prisma.translationHistory.upsert({
where: {
userId_word: {
//@ts-ignore
userId: user.id,
word,
},
},
create: {
word,
sense,
currentLanguage,
targetLanguage,
//@ts-ignore
userId: user.id,
},
update: {},
});
return res.status(201).json(tHistory);
} catch (error) {
console.error(`handleCreateTranslationHistory: ${error}`);
next("handleCreateTranslationHistory ERROR");
}
}
export async function handleGetTranslationHistory(
req: Request<{}, {}, {}, { page: number; limit: number }>,
res: Response,
next: NextFunction
) {
try {
const { user } = req;
let { page, limit } = req.query;
if (!page) page = 1;
if (!limit) limit = 18;
const [translations, totalRecords] = await prisma.$transaction([
prisma.translationHistory.findMany({
//@ts-ignore
where: { userId: user.id },
orderBy: {
createdAt: "desc",
},
take: Number(limit),
skip: (Number(page) - 1) * limit,
}),
prisma.translationHistory.count({
//@ts-ignore
where: { userId: user.id },
}),
]);
return res
.status(200)
.json({ translations, totalPages: Math.ceil(totalRecords / limit) });
} catch (error) {
console.error(`handleGetTranslationHistory: ${error}`);
next("handleGetTranslationHistory ERROR");
}
}
export async function handleDeleteTranslationHistory(
req: Request<{}, {}, { word: string; deleteOption: string }, {}>,
res: Response,
next: NextFunction
) {
try {
const { word, deleteOption } = req.body;
const { user } = req;
if (deleteOption === "deleteAll") {
const deleteStatus = await prisma.translationHistory.deleteMany({
//@ts-ignore
where: { userId: user.id },
});
return res.status(200).json({ deleteStatus });
}
const deleteStatus = await prisma.translationHistory.delete({
where: {
userId_word: {
word,
//@ts-ignore
userId: user.id,
},
},
});
return res.status(200).json({ deleteStatus });
} catch (error) {
console.error(`handleDeleteTranslationHistory: ${error}`);
next("handleDeleteTranslationHistory ERROR");
}
}
| src/controllers/userController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/middlewares/passportGoogleSSO.ts",
"retrieved_chunk": " }\n }\n )\n);\npassport.serializeUser((user, cb) => {\n cb(null, user.id);\n});\npassport.deserializeUser(async (id, cb) => {\n try {\n const user = await prisma.user.findUnique({",
"score": 22.263464006731116
},
{
"filename": "src/middlewares/passportGoogleSSO.ts",
"retrieved_chunk": " callbackURL: process.env.GOOGLE_CALLBACK_URL,\n passReqToCallback: true,\n },\n async (req, accessToken, refreshToken, profile, cb) => {\n try {\n const user = await prisma.user.upsert({\n where: { accountId: profile.id },\n create: {\n name: `${profile.name.givenName} ${profile.name.familyName}`,\n email: profile.emails[0].value,",
"score": 20.680736091172033
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " //@ts-ignore\n (new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000\n );\n if (diffDate >= e.numberOfDaysToForget) {\n return await prisma.practice.update({\n where: { id: e.id },\n data: { status: \"TEMPORARILY_FORGET\" },\n });\n } else {\n // console.log(\"skip!\");",
"score": 20.249368359007082
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " setTimeout(async () => {\n const [word] = await prisma.$transaction([\n prisma.word.create({\n data: {\n format,\n //@ts-ignore\n wordContent: resData.wordContent,\n less_frequent_senses:\n //@ts-ignore\n resData?.less_frequent_senses &&",
"score": 19.780325429708085
},
{
"filename": "src/middlewares/passportFacebookSSO.ts",
"retrieved_chunk": " callbackURL: process.env.FACEBOOK_CALLBACK_URL,\n profileFields: [\"id\", \"displayName\", \"photos\", \"email\"],\n },\n async (accessToken, refreshToken, profile, cb) => {\n try {\n const user = await prisma.user.upsert({\n where: { accountId: profile.id },\n create: {\n name: `${profile.displayName}`,\n email: profile.emails[0].value,",
"score": 19.2416743986148
}
] | typescript | prisma.translationHistory.count({ |
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import type { PracticeStatus } from "@prisma/client";
export async function handleGetUserInfo(
req: Request,
res: Response,
next: NextFunction
) {
try {
return res.status(200).json(req.user);
} catch (error) {
console.error("handleGetUserInfo ERROR: ", error);
return res.status(500).json("ERROR");
}
}
interface TranslationHistoryBody {
word: string;
sense: string;
currentLanguage: string;
targetLanguage: string;
translations_history: TranslationHistoryBody[];
}
export async function handleUpdatePracticeStatus(
req: Request<{}, {}, { status: PracticeStatus; wordContent: string }>,
res: Response,
next: NextFunction
) {
const { user } = req;
let { status, wordContent } = req.body;
try {
const practiceOwner = await prisma.practice.findUnique({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent,
},
},
});
const forgottenFrequencyOwner = practiceOwner?.forgottenFrequency
? practiceOwner?.forgottenFrequency
: 0;
const practice = await prisma.practice.update({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent,
},
},
select: {
status: true,
updatedAt: true,
},
data: {
status,
forgottenFrequency:
status === "REMEMBERED" ? 0 : forgottenFrequencyOwner + 1,
},
});
return res.status(200).json(practice);
} catch (error) {
console.error(`handleGetWordsPreview: ${error}`);
next("handleGetWordsPreview ERROR");
}
}
export async function handleGetWordsPractice(
req: Request<
{},
{},
{},
{ status: string; tags: string; page?: number; limit?: number }
>,
res: Response,
next: NextFunction
) {
const { user } = req;
let { status, page, tags, limit } = req.query;
if (!page) page = 1;
if (!limit) limit = 20;
const _status_ = status.split("+");
const _tags_ = tags.split("+");
const orConditions = [
..._status_.map((e) => ({ status: e })),
..._tags_.map((e) => ({ tag: e })),
];
try {
const [ | practices, totalRecords] = await prisma.$transaction([
prisma.practice.findMany({ |
where: {
//@ts-ignore
userId: user.id,
tag: tags ? { in: _tags_ } : undefined,
//@ts-ignore
status: status ? { in: _status_ } : undefined,
},
select: {
id: true,
status: true,
tag: true,
word: {
select: {
less_frequent_senses: { select: { sense: true } },
format: true,
wordContent: true,
senses: true,
},
},
},
take: Number(limit),
skip: (Number(page) - 1) * limit,
orderBy: {
createdAt: "desc",
},
}),
prisma.practice.count({
where: {
//@ts-ignore
userId: user.id,
tag: { in: _tags_ },
//@ts-ignore
status: { in: _status_ },
},
}),
]);
return res
.status(200)
.json({ practices, totalPages: Math.ceil(totalRecords / limit) });
} catch (error) {
console.error(`handleGetWordsPreview: ${error}`);
next("handleGetWordsPreview ERROR");
}
}
export async function handleGetWordsPreview(
req: Request<
{},
{},
{},
{ status: string; tag?: string; page?: number; limit?: number }
>,
res: Response,
next: NextFunction
) {
const { user } = req;
let { status, page, tag, limit } = req.query;
if (!page) page = 1;
if (!limit) limit = 18;
try {
const [words, totalRecords] = await prisma.$transaction([
prisma.practice.findMany({
where: {
//@ts-ignore
userId: user.id,
//@ts-ignore
status,
tag,
},
select: {
word: {
select: {
format: true,
wordContent: true,
senses: { select: { sense: true } },
},
},
},
take: Number(limit),
skip: (Number(page) - 1) * limit,
orderBy: {
createdAt: 'desc'
}
}),
prisma.practice.count({
where: {
//@ts-ignore
userId: user.id,
//@ts-ignore
status,
tag,
},
}),
]);
return res
.status(200)
.json({ words, totalPages: Math.ceil(totalRecords / limit) });
} catch (error) {
console.error(`handleGetWordsPreview: ${error}`);
next("handleGetWordsPreview ERROR");
}
}
export async function handleGetDashboardInfo(
req: Request<{}, {}, {}, { status: string }>,
res: Response,
next: NextFunction
) {
const { user } = req;
const { status } = req.query;
try {
const [statusCounting, historyCounting, favoriteCounting, tags] =
await prisma.$transaction([
prisma.practice.count({
//@ts-ignore
where: { userId: user.id, status },
}),
prisma.translationHistory.count({
//@ts-ignore
where: { userId: user.id },
}),
prisma.practice.count({
//@ts-ignore
where: { userId: user.id },
}),
prisma.practice.findMany({
//@ts-ignore
where: { userId: user.id },
distinct: ["tag"],
select: { tag: true },
}),
]);
return res
.status(200)
.json({ statusCounting, historyCounting, favoriteCounting, tags });
} catch (error) {
console.error(`handleGetDashboardInfo: ${error}`);
next("handleGetDashboardInfo ERROR");
}
}
export async function handleDeleteFavorite(
req: Request<{}, {}, { word: string }>,
res: Response,
next: NextFunction
) {
const { word } = req.body;
const { user } = req;
try {
const deletedStatus = await prisma.practice.delete({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent: word,
},
},
});
return res.status(200).json(deletedStatus);
} catch (error) {
console.error(`handleCreateFavorite: ${error}`);
next("handleCreateFavorite ERROR");
}
}
export async function handleCreateFavorite(
req: Request<
{},
{},
{ word: string; tag?: string; numberOfDaysToForget?: number }
>,
res: Response,
next: NextFunction
) {
const { word, numberOfDaysToForget, tag } = req.body;
const { user } = req;
try {
const practiceWord = await prisma.practice.upsert({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent: word,
},
},
create: {
word: { connect: { wordContent: word } },
//@ts-ignore
user: { connect: { id: user.id } },
numberOfDaysToForget,
tag,
},
update: {},
});
return res.status(201).json(practiceWord);
} catch (error) {
console.error(`handleCreateFavorite: ${error}`);
next("handleCreateFavorite ERROR");
}
}
export async function handleGetInfoFavorite(
req: Request<{}, {}, {}, { word: string }>,
res: Response,
next: NextFunction
) {
const { word } = req.query;
const { user } = req;
try {
const practiceWord = await prisma.practice.findUnique({
where: {
userId_wordContent: {
//@ts-ignore
userId: user.id,
wordContent: word,
},
},
select: {
createdAt: true,
},
});
return res.status(200).json(practiceWord);
} catch (error) {
console.error(`handleGetInfoFavorite: ${error}`);
next("handleGetInfoFavorite ERROR");
}
}
export async function handleCreateTranslationHistory(
req: Request<{}, {}, TranslationHistoryBody, {}>,
res: Response,
next: NextFunction
) {
const { word, sense, currentLanguage, targetLanguage, translations_history } =
req.body;
const { user } = req;
try {
//multiple create:
if (translations_history && translations_history.length > 0) {
const tHistory = await prisma.translationHistory.createMany({
data: translations_history.map((e) => ({
word: e.word,
sense: e.sense,
currentLanguage: e.currentLanguage,
targetLanguage: e.targetLanguage,
//@ts-ignore
userId: user.id,
})),
skipDuplicates: true,
});
return res.status(201).json(tHistory);
}
//single create:
const tHistory = await prisma.translationHistory.upsert({
where: {
userId_word: {
//@ts-ignore
userId: user.id,
word,
},
},
create: {
word,
sense,
currentLanguage,
targetLanguage,
//@ts-ignore
userId: user.id,
},
update: {},
});
return res.status(201).json(tHistory);
} catch (error) {
console.error(`handleCreateTranslationHistory: ${error}`);
next("handleCreateTranslationHistory ERROR");
}
}
export async function handleGetTranslationHistory(
req: Request<{}, {}, {}, { page: number; limit: number }>,
res: Response,
next: NextFunction
) {
try {
const { user } = req;
let { page, limit } = req.query;
if (!page) page = 1;
if (!limit) limit = 18;
const [translations, totalRecords] = await prisma.$transaction([
prisma.translationHistory.findMany({
//@ts-ignore
where: { userId: user.id },
orderBy: {
createdAt: "desc",
},
take: Number(limit),
skip: (Number(page) - 1) * limit,
}),
prisma.translationHistory.count({
//@ts-ignore
where: { userId: user.id },
}),
]);
return res
.status(200)
.json({ translations, totalPages: Math.ceil(totalRecords / limit) });
} catch (error) {
console.error(`handleGetTranslationHistory: ${error}`);
next("handleGetTranslationHistory ERROR");
}
}
export async function handleDeleteTranslationHistory(
req: Request<{}, {}, { word: string; deleteOption: string }, {}>,
res: Response,
next: NextFunction
) {
try {
const { word, deleteOption } = req.body;
const { user } = req;
if (deleteOption === "deleteAll") {
const deleteStatus = await prisma.translationHistory.deleteMany({
//@ts-ignore
where: { userId: user.id },
});
return res.status(200).json({ deleteStatus });
}
const deleteStatus = await prisma.translationHistory.delete({
where: {
userId_word: {
word,
//@ts-ignore
userId: user.id,
},
},
});
return res.status(200).json({ deleteStatus });
} catch (error) {
console.error(`handleDeleteTranslationHistory: ${error}`);
next("handleDeleteTranslationHistory ERROR");
}
}
| src/controllers/userController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " return res.status(200).json({\n ...wordDb,\n typesOfWord: wordDb.typesOfWord.map((e) => e.type),\n senses: wordDb.senses.map((s) => ({\n ...s,\n typeOfWord: s.typeOfWord?.type,\n })),\n less_frequent_senses: wordDb.less_frequent_senses.map((e) => e.sense),\n });\n }",
"score": 24.75334981569857
},
{
"filename": "src/utils/dbHelper.ts",
"retrieved_chunk": "//@ts-nocheck\nimport { prisma } from \"./prismaClient\";\n// prisma can not nested create in createMany, LMAO:\n// https://github.com/prisma/prisma/issues/5455\nexport async function createManySense(senses, wordId) {\n await prisma.$transaction(\n senses.map((e) => {\n return prisma.sense.create({\n data: {\n sense: e.sense,",
"score": 24.45775269302888
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " //@ts-ignore\n (new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000\n );\n if (diffDate >= e.numberOfDaysToForget) {\n return await prisma.practice.update({\n where: { id: e.id },\n data: { status: \"TEMPORARILY_FORGET\" },\n });\n } else {\n // console.log(\"skip!\");",
"score": 24.200038684017464
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " //@ts-ignore\n data: resData.examples.map((e) => ({\n en: e.en,\n vi: e.vi,\n keyword_en: e?.keyword_en,\n keyword_vi: e?.keyword_vi,\n })),\n },\n }\n : undefined,",
"score": 22.42513447149785
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " },\n select: {\n id: true,\n numberOfDaysToForget: true,\n updatedAt: true,\n },\n });\n await Promise.allSettled(\n practices.map(async (e) => {\n const diffDate = Math.ceil(",
"score": 21.909278255592856
}
] | typescript | practices, totalRecords] = await prisma.$transaction([
prisma.practice.findMany({ |
import axios from "axios";
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import { GLOSBE_API } from "../configs";
import {
translateWordGlosbe,
machineTranslation,
getGrammarGlosbe,
translateOxford,
translateCambridge,
} from "../libs";
import { getAudioInfo } from "../utils/getAudio";
import { createManySense, connectTypeOfWord } from "../utils/dbHelper";
import type { Language, LanguagePairs, Source } from "../types";
interface SearchQuery {
word: string;
format: LanguagePairs;
sensesFormat: Language;
}
interface AudioQuery {
source: Source;
}
export async function updatePracticeStatus(
req: Request,
res: Response,
next: NextFunction
) {
try {
const key = req.headers["x-api-key"];
if (
!key ||
typeof key !== "string" ||
key !== `${process.env.CRON_API_KEY}`
) {
return res.status(401).end();
}
const start = new Date(Date.now());
const practices = await prisma.practice.findMany({
where: {
status: "REMEMBERED",
},
select: {
id: true,
numberOfDaysToForget: true,
updatedAt: true,
},
});
await Promise.allSettled(
practices.map(async (e) => {
const diffDate = Math.ceil(
//@ts-ignore
(new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000
);
if (diffDate >= e.numberOfDaysToForget) {
return await prisma.practice.update({
where: { id: e.id },
data: { status: "TEMPORARILY_FORGET" },
});
} else {
// console.log("skip!");
}
})
);
//@ts-ignore
const cost = Math.abs(new Date(Date.now()) - start) / 1000;
return res
.status(200)
.json({ updateCost: `${cost} s`, totalRecords: practices.length });
} catch (error) {
console.error("error:: ", error);
next("500 ERROR");
}
}
export async function search(
req: Request<{}, {}, {}, SearchQuery>,
res: Response,
next: NextFunction
) {
const { format, word } = req.query;
const _format_ = format.split("-");
try {
if (!format || !word) throw new Error("missing query [format, word]");
const resData = await (
await axios.get(
`${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data;
if (resData?.after && Array.isArray(resData?.after)) {
const words = resData?.after.map((e: any) => String(e?.phrase));
return res.status(200).json({ words });
}
return res.status(404).json({ message: "word not found" });
} catch (error) {
console.log("SEARCH ERROR: ", error);
next();
}
}
export async function getWordDetail(
req: Request<
Pick<SearchQuery, "word">,
{},
{},
Pick<SearchQuery, "format"> & AudioQuery
>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { format, source } = req.query;
const _format_ = format.split("-");
if (!word) throw new Error("word missing");
if (!format) throw new Error("format missing");
//@ts-ignore
let resData;
if (format === "en-en") {
if (source === "cambridge") {
resData = await translateCambridge({ word });
} else {
resData = await translateOxford({ word });
}
if (resData) {
return res.status(200).json(resData);
} else {
throw new Error();
}
}
//get word from "cache":
const wordDb = await prisma.word.findUnique({
where: { wordContent: word },
include: {
examples: true,
senses: { include: { example: true, typeOfWord: true } },
less_frequent_senses: true,
similar_phrases: true,
typesOfWord: { select: { type: true } },
},
});
//"cache hit"
if (wordDb) {
return res.status(200).json({
...wordDb,
typesOfWord: wordDb.typesOfWord.map((e) => e.type),
senses: wordDb.senses.map((s) => ({
...s,
typeOfWord: s.typeOfWord?.type,
})),
less_frequent_senses: wordDb.less_frequent_senses.map((e) => e.sense),
});
}
console.time(`time scrape ${word}`);
resData = await translateWordGlosbe({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word,
});
console.timeEnd(`time scrape ${word}`);
if (resData) {
//cache data:
try {
setTimeout(async () => {
| const [word] = await prisma.$transaction([
prisma.word.create({ |
data: {
format,
//@ts-ignore
wordContent: resData.wordContent,
less_frequent_senses:
//@ts-ignore
resData?.less_frequent_senses &&
//@ts-ignore
resData?.less_frequent_senses.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.less_frequent_senses.map((e) => ({
sense: e,
})),
},
}
: undefined,
similar_phrases:
//@ts-ignore
resData?.similar_phrases &&
resData?.similar_phrases.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.similar_phrases.map((e) => ({
en: e.en,
vi: e.vi,
})),
},
}
: undefined,
examples:
//@ts-ignore
resData?.examples && resData.examples.length > 0
? {
createMany: {
//@ts-ignore
data: resData.examples.map((e) => ({
en: e.en,
vi: e.vi,
keyword_en: e?.keyword_en,
keyword_vi: e?.keyword_vi,
})),
},
}
: undefined,
},
}),
prisma.typeOfWord.createMany({
data:
//@ts-ignore
resData.typesOfWord && resData.typesOfWord.length > 0
? //@ts-ignore
resData.typesOfWord.map((e) => ({ type: e }))
: [],
skipDuplicates: true,
}),
]);
//@ts-ignore
if (resData.typesOfWord && resData.typesOfWord.length > 0) {
await Promise.allSettled([
//@ts-ignore
await connectTypeOfWord(resData.typesOfWord, word.wordContent),
//@ts-ignore
await createManySense(resData.senses, word.id),
]);
} else {
//@ts-ignore
await createManySense(resData.senses, word.id);
}
}, 500);
} catch (error) {
console.log("cache ERROR: ", error);
}
return res.status(200).json(resData);
} else {
return res.status(404).json({ message: "word detail not found" });
}
} catch (error) {
console.log("getWordDetail: ", error);
next();
}
}
export async function getGrammar(
req: Request<Pick<SearchQuery, "word">, {}, {}, {}>,
res: Response,
next: NextFunction
) {
const { word } = req.params;
const resData = await getGrammarGlosbe({ word });
if (resData) {
return res.status(200).json({ grammars: resData });
} else {
return res.status(404).json({ message: "grammars not found" });
}
}
export async function getWordDetailByMachine(
req: Request<{}, {}, { sentence: string }, Pick<SearchQuery, "format">>,
res: Response,
next: NextFunction
) {
const { sentence } = req.body;
const { format } = req.query;
const _format_ = format.split("-");
if (!sentence) throw new Error("word missing");
if (!format) throw new Error("format missing");
try {
const resData = await machineTranslation({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word: sentence,
});
if (resData) {
return res.status(200).json(resData);
}
return res
.status(404)
.json({ message: "word detail by machine not found" });
} catch (error) {
console.log("getWordDetailByMachine error: ", error);
next();
}
}
export async function getAudio(
req: Request<Pick<SearchQuery, "word">, {}, {}, AudioQuery>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { source } = req.query;
const audios = await getAudioInfo({ word, format: "en", source });
return res.status(200).json({ audios });
} catch (error) {}
}
| src/controllers/wordController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/utils/dbHelper.ts",
"retrieved_chunk": "export async function connectTypeOfWord(typesOfWord, word) {\n await prisma.$transaction(\n typesOfWord.map((type) => {\n return prisma.word.update({\n where: { wordContent: word },\n data: {\n typesOfWord: { connect: { type } },\n },\n });\n })",
"score": 17.64922188783737
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " word,\n}: {\n language_1: Language;\n language_2: Language;\n word: string;\n}) {\n try {\n const [google] = await Promise.allSettled([\n // (\n // await axios.post(",
"score": 17.41696225621187
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " language_2: Language;\n word: string;\n}) {\n try {\n const raw = await (\n await axios.get(`${GLOSBE_URL}/${language_1}/${language_2}/${word}`)\n ).data;\n //@ts-ignore\n const document = parse(raw);\n const wordContent = document.querySelector(\"span.break-words\")?.textContent;",
"score": 16.37765434762488
},
{
"filename": "src/utils/dbHelper.ts",
"retrieved_chunk": "//@ts-nocheck\nimport { prisma } from \"./prismaClient\";\n// prisma can not nested create in createMany, LMAO:\n// https://github.com/prisma/prisma/issues/5455\nexport async function createManySense(senses, wordId) {\n await prisma.$transaction(\n senses.map((e) => {\n return prisma.sense.create({\n data: {\n sense: e.sense,",
"score": 14.23599989855883
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": "}: {\n format: Language;\n word: string;\n}) {\n let raw_phonetics;\n let phonetics;\n try {\n raw_phonetics = await (\n await axios.get(`${GLOSBE_URL}/api/audios/${format}/${word}`)\n ).data;",
"score": 14.20995214810931
}
] | typescript | const [word] = await prisma.$transaction([
prisma.word.create({ |
import axios from "axios";
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import { GLOSBE_API } from "../configs";
import {
translateWordGlosbe,
machineTranslation,
getGrammarGlosbe,
translateOxford,
translateCambridge,
} from "../libs";
import { getAudioInfo } from "../utils/getAudio";
import { createManySense, connectTypeOfWord } from "../utils/dbHelper";
import type { Language, LanguagePairs, Source } from "../types";
interface SearchQuery {
word: string;
format: LanguagePairs;
sensesFormat: Language;
}
interface AudioQuery {
source: Source;
}
export async function updatePracticeStatus(
req: Request,
res: Response,
next: NextFunction
) {
try {
const key = req.headers["x-api-key"];
if (
!key ||
typeof key !== "string" ||
key !== `${process.env.CRON_API_KEY}`
) {
return res.status(401).end();
}
const start = new Date(Date.now());
const practices = await prisma.practice.findMany({
where: {
status: "REMEMBERED",
},
select: {
id: true,
numberOfDaysToForget: true,
updatedAt: true,
},
});
await Promise.allSettled(
practices.map(async (e) => {
const diffDate = Math.ceil(
//@ts-ignore
(new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000
);
if (diffDate >= e.numberOfDaysToForget) {
return await prisma.practice.update({
where: { id: e.id },
data: { status: "TEMPORARILY_FORGET" },
});
} else {
// console.log("skip!");
}
})
);
//@ts-ignore
const cost = Math.abs(new Date(Date.now()) - start) / 1000;
return res
.status(200)
.json({ updateCost: `${cost} s`, totalRecords: practices.length });
} catch (error) {
console.error("error:: ", error);
next("500 ERROR");
}
}
export async function search(
req: Request<{}, {}, {}, SearchQuery>,
res: Response,
next: NextFunction
) {
const { format, word } = req.query;
const _format_ = format.split("-");
try {
if (!format || !word) throw new Error("missing query [format, word]");
const resData = await (
await axios.get(
`${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data;
if (resData?.after && Array.isArray(resData?.after)) {
const words = resData?.after.map((e: any) => String(e?.phrase));
return res.status(200).json({ words });
}
return res.status(404).json({ message: "word not found" });
} catch (error) {
console.log("SEARCH ERROR: ", error);
next();
}
}
export async function getWordDetail(
req: Request<
Pick<SearchQuery, "word">,
{},
{},
Pick<SearchQuery, "format"> & AudioQuery
>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { format, source } = req.query;
const _format_ = format.split("-");
if (!word) throw new Error("word missing");
if (!format) throw new Error("format missing");
//@ts-ignore
let resData;
if (format === "en-en") {
if (source === "cambridge") {
resData = await translateCambridge({ word });
} else {
resData = await translateOxford({ word });
}
if (resData) {
return res.status(200).json(resData);
} else {
throw new Error();
}
}
//get word from "cache":
const wordDb = await prisma.word.findUnique({
where: { wordContent: word },
include: {
examples: true,
senses: { include: { example: true, typeOfWord: true } },
less_frequent_senses: true,
similar_phrases: true,
typesOfWord: { select: { type: true } },
},
});
//"cache hit"
if (wordDb) {
return res.status(200).json({
...wordDb,
typesOfWord: wordDb.typesOfWord.map((e) => e.type),
senses: wordDb.senses.map((s) => ({
...s,
typeOfWord: s.typeOfWord?.type,
})),
less_frequent_senses: wordDb.less_frequent_senses.map((e) => e.sense),
});
}
console.time(`time scrape ${word}`);
resData = await translateWordGlosbe({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word,
});
console.timeEnd(`time scrape ${word}`);
if (resData) {
//cache data:
try {
setTimeout(async () => {
const [word] = await prisma.$transaction([
prisma.word.create({
data: {
format,
//@ts-ignore
wordContent: resData.wordContent,
less_frequent_senses:
//@ts-ignore
resData?.less_frequent_senses &&
//@ts-ignore
resData?.less_frequent_senses.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.less_frequent_senses.map((e) => ({
sense: e,
})),
},
}
: undefined,
similar_phrases:
//@ts-ignore
resData?.similar_phrases &&
resData?.similar_phrases.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.similar_phrases.map((e) => ({
en: e.en,
vi: e.vi,
})),
},
}
: undefined,
examples:
//@ts-ignore
resData?.examples && resData.examples.length > 0
? {
createMany: {
//@ts-ignore
data: resData.examples.map((e) => ({
en: e.en,
vi: e.vi,
keyword_en: e?.keyword_en,
keyword_vi: e?.keyword_vi,
})),
},
}
: undefined,
},
}),
prisma.typeOfWord.createMany({
data:
//@ts-ignore
resData.typesOfWord && resData.typesOfWord.length > 0
? //@ts-ignore
resData.typesOfWord.map((e) => ({ type: e }))
: [],
skipDuplicates: true,
}),
]);
//@ts-ignore
if (resData.typesOfWord && resData.typesOfWord.length > 0) {
await Promise.allSettled([
//@ts-ignore
await connectTypeOfWord(resData.typesOfWord, word.wordContent),
//@ts-ignore
await createManySense(resData.senses, word.id),
]);
} else {
//@ts-ignore
await createManySense(resData.senses, word.id);
}
}, 500);
} catch (error) {
console.log("cache ERROR: ", error);
}
return res.status(200).json(resData);
} else {
return res.status(404).json({ message: "word detail not found" });
}
} catch (error) {
console.log("getWordDetail: ", error);
next();
}
}
export async function getGrammar(
req: Request<Pick<SearchQuery, "word">, {}, {}, {}>,
res: Response,
next: NextFunction
) {
const { word } = req.params;
const resData = await getGrammarGlosbe({ word });
if (resData) {
return res.status(200).json({ grammars: resData });
} else {
return res.status(404).json({ message: "grammars not found" });
}
}
export async function getWordDetailByMachine(
req: Request<{}, {}, { sentence: string }, Pick<SearchQuery, "format">>,
res: Response,
next: NextFunction
) {
const { sentence } = req.body;
const { format } = req.query;
const _format_ = format.split("-");
if (!sentence) throw new Error("word missing");
if (!format) throw new Error("format missing");
try {
const resData = await machineTranslation({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word: sentence,
});
if (resData) {
return res.status(200).json(resData);
}
return res
.status(404)
.json({ message: "word detail by machine not found" });
} catch (error) {
console.log("getWordDetailByMachine error: ", error);
next();
}
}
export async function getAudio(
req: Request<Pick<SearchQuery, "word">, {}, {}, AudioQuery>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { source } = req.query;
const audios = | await getAudioInfo({ word, format: "en", source }); |
return res.status(200).json({ audios });
} catch (error) {}
}
| src/controllers/wordController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/middlewares/zodValidate.ts",
"retrieved_chunk": "import { NextFunction, Request, Response } from \"express\";\nimport { AnyZodObject } from \"zod\";\nexport const validate =\n (schema: AnyZodObject) =>\n async (req: Request, res: Response, next: NextFunction) => {\n try {\n await schema.parseAsync({\n body: req.body,\n query: req.query,\n params: req.params,",
"score": 30.784176413413793
},
{
"filename": "src/utils/getAudio.ts",
"retrieved_chunk": "import { getAudioGlosbe, getAudioOxford, getAudioCambridge } from \"../libs\";\nimport type { Source } from \"../types\";\nexport async function getAudioInfo({\n word,\n format,\n source,\n}: {\n word: string;\n format: \"en\" | \"vi\";\n source: Source;",
"score": 29.5593216006763
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " next(\"handleGetTranslationHistory ERROR\");\n }\n}\nexport async function handleDeleteTranslationHistory(\n req: Request<{}, {}, { word: string; deleteOption: string }, {}>,\n res: Response,\n next: NextFunction\n) {\n try {\n const { word, deleteOption } = req.body;",
"score": 25.29109144054711
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": "}\nexport async function handleCreateTranslationHistory(\n req: Request<{}, {}, TranslationHistoryBody, {}>,\n res: Response,\n next: NextFunction\n) {\n const { word, sense, currentLanguage, targetLanguage, translations_history } =\n req.body;\n const { user } = req;\n try {",
"score": 25.027446001525384
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": "export async function handleGetDashboardInfo(\n req: Request<{}, {}, {}, { status: string }>,\n res: Response,\n next: NextFunction\n) {\n const { user } = req;\n const { status } = req.query;\n try {\n const [statusCounting, historyCounting, favoriteCounting, tags] =\n await prisma.$transaction([",
"score": 24.89888810615904
}
] | typescript | await getAudioInfo({ word, format: "en", source }); |
import axios from "axios";
import type { NextFunction, Request, Response } from "express";
import { prisma } from "../utils/prismaClient";
import { GLOSBE_API } from "../configs";
import {
translateWordGlosbe,
machineTranslation,
getGrammarGlosbe,
translateOxford,
translateCambridge,
} from "../libs";
import { getAudioInfo } from "../utils/getAudio";
import { createManySense, connectTypeOfWord } from "../utils/dbHelper";
import type { Language, LanguagePairs, Source } from "../types";
interface SearchQuery {
word: string;
format: LanguagePairs;
sensesFormat: Language;
}
interface AudioQuery {
source: Source;
}
export async function updatePracticeStatus(
req: Request,
res: Response,
next: NextFunction
) {
try {
const key = req.headers["x-api-key"];
if (
!key ||
typeof key !== "string" ||
key !== `${process.env.CRON_API_KEY}`
) {
return res.status(401).end();
}
const start = new Date(Date.now());
const practices = await prisma.practice.findMany({
where: {
status: "REMEMBERED",
},
select: {
id: true,
numberOfDaysToForget: true,
updatedAt: true,
},
});
await Promise.allSettled(
practices.map(async (e) => {
const diffDate = Math.ceil(
//@ts-ignore
(new Date(Date.now()) - new Date(String(e.updatedAt))) / 86400000
);
if (diffDate >= e.numberOfDaysToForget) {
return await prisma.practice.update({
where: { id: e.id },
data: { status: "TEMPORARILY_FORGET" },
});
} else {
// console.log("skip!");
}
})
);
//@ts-ignore
const cost = Math.abs(new Date(Date.now()) - start) / 1000;
return res
.status(200)
.json({ updateCost: `${cost} s`, totalRecords: practices.length });
} catch (error) {
console.error("error:: ", error);
next("500 ERROR");
}
}
export async function search(
req: Request<{}, {}, {}, SearchQuery>,
res: Response,
next: NextFunction
) {
const { format, word } = req.query;
const _format_ = format.split("-");
try {
if (!format || !word) throw new Error("missing query [format, word]");
const resData = await (
await axios.get(
`${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data;
if (resData?.after && Array.isArray(resData?.after)) {
const words = resData?.after.map((e: any) => String(e?.phrase));
return res.status(200).json({ words });
}
return res.status(404).json({ message: "word not found" });
} catch (error) {
console.log("SEARCH ERROR: ", error);
next();
}
}
export async function getWordDetail(
req: Request<
Pick<SearchQuery, "word">,
{},
{},
Pick<SearchQuery, "format"> & AudioQuery
>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { format, source } = req.query;
const _format_ = format.split("-");
if (!word) throw new Error("word missing");
if (!format) throw new Error("format missing");
//@ts-ignore
let resData;
if (format === "en-en") {
if (source === "cambridge") {
resData = await translateCambridge({ word });
} else {
resData = await translateOxford({ word });
}
if (resData) {
return res.status(200).json(resData);
} else {
throw new Error();
}
}
//get word from "cache":
const wordDb = await prisma.word.findUnique({
where: { wordContent: word },
include: {
examples: true,
senses: { include: { example: true, typeOfWord: true } },
less_frequent_senses: true,
similar_phrases: true,
typesOfWord: { select: { type: true } },
},
});
//"cache hit"
if (wordDb) {
return res.status(200).json({
...wordDb,
typesOfWord: wordDb.typesOfWord.map((e) => e.type),
| senses: wordDb.senses.map((s) => ({ |
...s,
typeOfWord: s.typeOfWord?.type,
})),
less_frequent_senses: wordDb.less_frequent_senses.map((e) => e.sense),
});
}
console.time(`time scrape ${word}`);
resData = await translateWordGlosbe({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word,
});
console.timeEnd(`time scrape ${word}`);
if (resData) {
//cache data:
try {
setTimeout(async () => {
const [word] = await prisma.$transaction([
prisma.word.create({
data: {
format,
//@ts-ignore
wordContent: resData.wordContent,
less_frequent_senses:
//@ts-ignore
resData?.less_frequent_senses &&
//@ts-ignore
resData?.less_frequent_senses.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.less_frequent_senses.map((e) => ({
sense: e,
})),
},
}
: undefined,
similar_phrases:
//@ts-ignore
resData?.similar_phrases &&
resData?.similar_phrases.length > 0
? {
createMany: {
//@ts-ignore
data: resData?.similar_phrases.map((e) => ({
en: e.en,
vi: e.vi,
})),
},
}
: undefined,
examples:
//@ts-ignore
resData?.examples && resData.examples.length > 0
? {
createMany: {
//@ts-ignore
data: resData.examples.map((e) => ({
en: e.en,
vi: e.vi,
keyword_en: e?.keyword_en,
keyword_vi: e?.keyword_vi,
})),
},
}
: undefined,
},
}),
prisma.typeOfWord.createMany({
data:
//@ts-ignore
resData.typesOfWord && resData.typesOfWord.length > 0
? //@ts-ignore
resData.typesOfWord.map((e) => ({ type: e }))
: [],
skipDuplicates: true,
}),
]);
//@ts-ignore
if (resData.typesOfWord && resData.typesOfWord.length > 0) {
await Promise.allSettled([
//@ts-ignore
await connectTypeOfWord(resData.typesOfWord, word.wordContent),
//@ts-ignore
await createManySense(resData.senses, word.id),
]);
} else {
//@ts-ignore
await createManySense(resData.senses, word.id);
}
}, 500);
} catch (error) {
console.log("cache ERROR: ", error);
}
return res.status(200).json(resData);
} else {
return res.status(404).json({ message: "word detail not found" });
}
} catch (error) {
console.log("getWordDetail: ", error);
next();
}
}
export async function getGrammar(
req: Request<Pick<SearchQuery, "word">, {}, {}, {}>,
res: Response,
next: NextFunction
) {
const { word } = req.params;
const resData = await getGrammarGlosbe({ word });
if (resData) {
return res.status(200).json({ grammars: resData });
} else {
return res.status(404).json({ message: "grammars not found" });
}
}
export async function getWordDetailByMachine(
req: Request<{}, {}, { sentence: string }, Pick<SearchQuery, "format">>,
res: Response,
next: NextFunction
) {
const { sentence } = req.body;
const { format } = req.query;
const _format_ = format.split("-");
if (!sentence) throw new Error("word missing");
if (!format) throw new Error("format missing");
try {
const resData = await machineTranslation({
language_1: _format_[0] as Language,
language_2: _format_[1] as Language,
word: sentence,
});
if (resData) {
return res.status(200).json(resData);
}
return res
.status(404)
.json({ message: "word detail by machine not found" });
} catch (error) {
console.log("getWordDetailByMachine error: ", error);
next();
}
}
export async function getAudio(
req: Request<Pick<SearchQuery, "word">, {}, {}, AudioQuery>,
res: Response,
next: NextFunction
) {
try {
const { word } = req.params;
const { source } = req.query;
const audios = await getAudioInfo({ word, format: "en", source });
return res.status(200).json({ audios });
} catch (error) {}
}
| src/controllers/wordController.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " if (typesOfWord && wordContent && senses) {\n return {\n wordContent,\n typesOfWord,\n senses,\n less_frequent_senses,\n similar_phrases,\n examples,\n };\n } else {",
"score": 32.85709953807991
},
{
"filename": "src/utils/dbHelper.ts",
"retrieved_chunk": "export async function connectTypeOfWord(typesOfWord, word) {\n await prisma.$transaction(\n typesOfWord.map((type) => {\n return prisma.word.update({\n where: { wordContent: word },\n data: {\n typesOfWord: { connect: { type } },\n },\n });\n })",
"score": 27.538462295405218
},
{
"filename": "src/libs/oxford.dictionary.ts",
"retrieved_chunk": " });\n return {\n wordContent,\n typesOfWord: [typesOfWord],\n senses,\n };\n } catch (error) {\n console.log(\"translateOxford error: \", error);\n return null;\n }",
"score": 22.534487486500428
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " const typesOfWord = document\n .querySelectorAll(\n \"#phraseDetails_activator-0 > div.text-xl.text-gray-900.px-1.pb-1 > span.text-xxs.text-gray-500 > span\"\n )\n .map((e) => e?.textContent);\n const senses = document\n .querySelectorAll(\n \"#dictionary-content > article > div > div > section.bg-white.px-1 > div.pl-1 > div > ul.pr-1 > li\"\n )\n .map((li) => {",
"score": 21.79835799212052
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " word: {\n select: {\n less_frequent_senses: { select: { sense: true } },\n format: true,\n wordContent: true,\n senses: true,\n },\n },\n },\n take: Number(limit),",
"score": 20.582917200714665
}
] | typescript | senses: wordDb.senses.map((s) => ({ |
import { CAMBRIDGE_DICTIONARY_URL } from "../configs";
import { parse } from "node-html-parser";
import axios from "axios";
import { normalizeString } from "../utils/string";
export async function getAudioCambridge({ word }: { word: string }) {
let raw_phonetics;
let phonetics;
try {
raw_phonetics = await (
await axios.get(
`${CAMBRIDGE_DICTIONARY_URL}/vi/dictionary/english/${word}`
)
).data;
const document = parse(raw_phonetics);
const uk_audio =
String(CAMBRIDGE_DICTIONARY_URL) +
document.querySelector("#audio1 source")?.getAttribute("src");
const uk_phonetic = document.querySelector(
"#page-content > div.page > div:nth-child(1) > div.link > div > div.di-body > div > div > div:nth-child(1) > div.pos-header.dpos-h > span.uk.dpron-i > span.pron.dpron"
)?.textContent;
const raw_us_audio = document
.querySelector("#audio2 source")
?.getAttribute("src");
if (!raw_us_audio) return null;
const us_audio = String(CAMBRIDGE_DICTIONARY_URL) + raw_us_audio;
const us_phonetic = document.querySelector(
"#page-content > div.page > div:nth-child(1) > div.link > div > div.di-body > div > div > div:nth-child(1) > div.pos-header.dpos-h > span.us.dpron-i > span.pron.dpron"
)?.textContent;
phonetics = [
{ phrase: uk_phonetic, author: "Cambridge_English", url: uk_audio },
{ phrase: us_phonetic, author: "Cambridge_American", url: us_audio },
];
} catch (error) {
console.error("get audio cambridge error: ", error);
}
return phonetics;
}
export async function translateCambridge({ word }: { word: string }) {
try {
const rawData = await (
await axios.get(
`${CAMBRIDGE_DICTIONARY_URL}/vi/dictionary/english/${word}`
)
).data;
const document = parse(rawData);
const wordContent = document.querySelector(
"#page-content > div.page > div:nth-child(1) > div.link > div > div.di-body > div > div > div:nth-child(1) > div.pos-header.dpos-h > div.di-title > span > span"
)?.textContent;
if (!wordContent) throw new Error();
const typesOfWord = document
.querySelectorAll(".pr.entry-body__el .pos.dpos")
.map((span) => span?.textContent);
const senses = document
.querySelectorAll(".pr.entry-body__el")
.map((container) => {
const typeOfWord = container.querySelector(".pos.dpos")?.textContent;
const sense = container.querySelector(".def.ddef_d.db")?.textContent;
const examples = container
.querySelectorAll(".examp.dexamp")
.map((div) => {
return | normalizeString(String(div?.textContent)); |
});
return { typeOfWord, sense, examples };
});
return { wordContent, typesOfWord: [...new Set(typesOfWord)], senses };
} catch (error) {
console.log("translateCambridge error ", error);
return null;
}
}
| src/libs/cambridge.dictionary.ts | leephan2k1-v-dictionary-api-d7c2d42 | [
{
"filename": "src/libs/oxford.dictionary.ts",
"retrieved_chunk": " ).data;\n const document = parse(rawData);\n const wordContent = document.querySelector(`#${word}_h_1`)?.textContent;\n if (!wordContent) throw new Error();\n const typesOfWord = document.querySelector(`span.pos`)?.textContent;\n const senses = document.querySelectorAll(\"span.def\").map((span, index) => {\n const examples = document\n .querySelectorAll(`#${word}_sng_${index + 1} > ul > li`)\n .map((li) => li?.textContent);\n return { sense: span?.textContent, typeOfWord: typesOfWord, examples };",
"score": 50.66493578574942
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " example,\n };\n });\n const less_frequent_senses = document\n .querySelectorAll(\n \"#less-frequent-translations-container-0 > li > div:nth-child(2) > ul > li\"\n )\n .map((li) => li?.textContent);\n const similar_phrases = document\n .querySelectorAll(\"#simmilar-phrases > ul > li\")",
"score": 49.02423554683898
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " .map((li) => {\n return {\n [language_1]: li.querySelector(\"a\")?.textContent,\n [language_2]: normalizeString(\n String(li.querySelector(\".dir-aware-pl-2\")?.textContent)\n ),\n };\n });\n const examples = document\n .querySelectorAll(",
"score": 45.99525824063079
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " ? normalizeString(\n String(\n div.querySelector(\"div:nth-child(1) .keyword\")?.textContent\n )\n )\n : undefined,\n [language_2]: normalizeString(\n String(div.querySelector(\"div:nth-child(2)\")?.textContent)\n ),\n [`keyword_${language_2}`]: div.querySelector(",
"score": 40.028911290893504
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " const sense = li.querySelector(\"h3\")?.textContent;\n const typeOfWord = li.querySelector(\n \"span.text-xxs.text-gray-500 > span\"\n )?.textContent;\n const topic = li.querySelector(\"div.py-1 > p > span\");\n // check if word has example or not:\n const example = li.querySelector(\"div > p.dir-aware-pr-1\")\n ? {\n [language_1]: normalizeString(\n String(li.querySelector(\"div > p.dir-aware-pr-1\")?.textContent)",
"score": 39.85492329657426
}
] | typescript | normalizeString(String(div?.textContent)); |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory = deepClone(completionStringOrMessageHistory);
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if (isChatRequest(request)) {
const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
} else if (isCompletionRequest(request)) {
const completionResponse = await openai.createCompletion(request, openAIRequestOptions);
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
| } else if (isModerationRequest(request)) { |
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 53.312139127710324
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...moderationResponse, prompts, model: builtRequest.model });\n return moderationResponse as UseAIResponses<T>;\n }\n if (isCompletionRequest(builtRequest)) {\n const completionResponse: CompletionResponse = {\n ...aiResponse,\n message: responseTry\n };\n console.log('COMPLETION RESPONSE :==: ', completionResponse)\n logAiResult<T>({ ...completionResponse, prompts, model: builtRequest.model });",
"score": 50.233242687871396
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const responseTry = await performRequest(builtRequest);\n aiResponse.rawResponses.push(responseTry);\n if ('undefined' === typeof responseTry) {\n const noChoices = 'Open AI returned no choices.'\n aiResponse.failures.push(noChoices);\n throw new Error(noChoices);\n }\n if ('boolean' === typeof responseTry) {\n const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };\n console.log('MODERATION RESPONSE :==: ', moderationResponse)",
"score": 40.57604587958021
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " 'commit': {\n type: 'boolean',\n description: 'Will commit edits to the generated branch',\n default: true,\n },\n 'pull-request': {\n type: 'boolean',\n description: 'Will create and add to 1 pull request per generated branch',\n default: true,\n },",
"score": 40.248376577694835
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " return completionResponse as UseAIResponses<T>;\n }\n async function resolveAttempt(attempt: string, retriesRemaining: number): Promise<ChatResponse<T>> {\n try {\n const { supportingText, message } = parseChatAttempt<T>(attempt);\n const chatResponse = {\n ...aiResponse,\n supportingText,\n message\n };",
"score": 38.69634982435476
}
] | typescript | } else if (isModerationRequest(request)) { |
import { ChatCompletionRequestMessage } from "openai";
import type { GuardValidations } from "../types";
// const fileEditorPrompt = [
// { role: 'system', content: 'you are a helpful file editing assistant' },
// { role: 'user', content: 'edit ${prompt1} with regard to ${prompt2}. only show edited lines. remember to encase the edited code inside proper markdown "```" header. \n\n ${prompt1}:\n${prompt3}' }
// ];
export const fileEditorMessages: ChatCompletionRequestMessage[] = [
{ role: 'system', content: 'You, CodeCommenter, follow user instructions to add, edit, and delete text in specific ways, leaving change comments. You only reply with the line number + the change comment + the new content of the line. 3 possible static comments: "/* change: added text */", "/* change: edited text */", and "/* change: fully removed text */". Your reply includes only changed lines which have change comments, and clearly formats it in an anonymous markdown backtick block.' },
// { role: 'system', content: 'You reply with: "I only edited line {number of each edited line}, so I am just going to show you {number of edited lines} lines, including empty lines:"' },
{ role: 'user', content: `add_text_example.txt
instructions: put a happy face on line 4
1. Lorem ipsum dolor sit amet.
2. Lorem ipsum dolor sit amet.
3. Lorem ipsum dolor sit amet.
4. Lorem ipsum dolor sit amet.
5. Lorem ipsum dolor sit amet.
6. Lorem ipsum dolor sit amet.
7. Lorem ipsum dolor sit amet.`},
{ role: 'assistant', content: `1 text change signified: I edited line 4, which is 1 total edited line. Here is the 1 edited line containing a signifier, including its line number:
\`\`\`
4. Lorem ipsum dolor sit amet. :) /* change: added text */
\`\`\`
Please find the 1 change above this line.`},
{ role: 'user', content: `remove_and_edit_text_example.js
instructions: remove any console logs. change ts.configPath to ts.configRoot
1. const config = getConfig();
2. if (!config.ts.compDir) {
3. console.log('hey');
4. throw new Error('Missing ts.compDir.')
5. }
6.
7. if (!config.ts.configPath) {
8. console.log('testing removals');
9. throw new Error('Missing ts.configPath.')
10. }`},
{ role: 'assistant', content: `4 text changes signified: I edited lines 3, 7, 8, and 9, which is 4 total edited lines. Here are the 4 lines containing signifiers, including their line numbers:
\`\`\`
3. /* change: fully removed text */
7. if (!config.ts.configRoot) { /* change: edited text */
8. /* change: fully removed text */
9. throw new Error('Missing ts.configRoot.') /* change: edited text */
\`\`\`
Please find the 4 changes above this line.` },
{ role: 'user', content: `\${prompt1}
\${prompt2}
\${prompt3}`}
];
// const testSystem = 'you are a helpful typescript coding assistant';
// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown "```typescript" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'
const fileEditorResponseRegex = /^\d+./igm;
export type FileEditorResponse = `${number}. ${string}`;
export | function isFileEditorResult(obj: GuardValidations): boolean { |
return 'string' === typeof obj && fileEditorResponseRegex.test(obj);
} | src/lib/prompts/file_editor_prompt.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown \"```typescript\" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'\nexport const guidedEditMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'I change code from a JSON object to an array based on the target state.' },\n { role: 'assistant', content: `What I need:\n JSON object with code statements\n Desired state of the code statements\n What I do:\n Check which statements in the JSON object can help reach the desired state.\n Keep only useful statements.\n Change the statements to reach the target state. I can update, insert, or remove statements.",
"score": 113.03256499615102
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "// @@@\n// &&&\n// Following Steps:\n// Provide the necessary context in the statements for me to carry out the modifications. Use the keywords STATEMENTS_JSON and TARGET_STATE to convey the required inputs:\n// TARGET_STATE --- <an english phrase with some coding terms>\n// STATEMENTS_JSON --- <a plain old javascript object (POJO)>\n// On receiving TARGET_STATE and STATEMENTS_JSON, I'll start whittling away on the STATEMENTS_JSON as needed, to achieve TARGET_STATE, in order to derive RESPONSE_ARRAY.`},\n// { role: 'user', content: ' TARGET_STATE --- ${prompt1}\\n STATEMENTS_JSON --- ${prompt2}' }\n// ];\n// const testSystem = 'you are a helpful typescript coding assistant';",
"score": 55.887474046384064
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\n// const createTypePrompt = 'Complete the following typescript type with 4-7 unconventionally named properties, using string, number or boolean, starting with its opening bracket, \"type ${prompt1} =';\n// const createTypeMessages = [\n// { role: 'system', content: 'I, TypescriptTypeGeneratorGPT, respond with a code statement declaring a Typescript type, based on the name of a type.' },\n// { role: 'assistant', content: `This message describes how \\${prompt1} will be generated and returned in the next message.\n// 1. Parse Name: You provided a name in the format of ITypeName, \\${prompt1}, which I will evaluate to determine its general informational context.\n// 2. Primary Action: Generate TYPE_DEFINITION of 4-7 unconventionally named properties.\n// 3. Primary Validation: TYPE_DEFINITION is validated as starting with text \"type \\${prompt1} = {\" with the rest of TYPE_DEFINITION to follow.\n// 4. Secondary Validation: Exact response text verified to be formatted in the following pattern:",
"score": 43.4453612376995
},
{
"filename": "src/lib/prompts/convert_purpose_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\nexport const convertPurposeMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'You respond with a single gerund phrase, 5 to 8 words, which will complete the user\\'s sentence. For example, \"walking in the sunshine with you\".' },\n { role: 'assistant', content: 'Give me an incomplete sentence that I can complete with a gerund phrase. For example, if you said \"Our favorite past time is\", I might respond \"walking in the sunshine with you\"' },\n { role: 'user', content: 'An organization named \"${prompt1}\" is interested in \"${prompt2}\" and their mission statement is' }\n];\nexport type ConvertPurposeResult = string;\nconst convertPurposeRegex = /\\b[a-z]*ing\\b/i;\nexport function isConvertPurposeResult(obj: GuardValidations): obj is ConvertPurposeResult {",
"score": 40.641416259211
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": " @@@\n &&&\n Next steps:\n Give me the desired state and JSON object with code statements using these keywords:\n TARGET_STATE --- <phrase with code terms>\n STATEMENTS_JSON --- <a simple JSON object>\n I'll change the code in the JSON object to reach the target state and create the final array.`},\n { role: 'user', content: ' TARGET_STATE --- ${prompt1}\\n STATEMENTS_JSON --- ${prompt2}' }\n];\nexport type GuidedEditKeyPrefix = 'statement' | 'above' | 'below';",
"score": 39.23638186640871
}
] | typescript | function isFileEditorResult(obj: GuardValidations): boolean { |
#!/usr/bin/env node
import yargs from 'yargs/yargs';
import { config, saveConfig, getConfigValue, checkConfigExists } from './config';
import * as spells from './spells';
import { IPrompts } from '../lib/prompts';
const parser = yargs(process.argv.slice(2))
// .options({
// 'config': {
// alias: 'c',
// describe: 'Path to the configuration file',
// default: 'config.json',
// type: 'string',
// },
// 'verbose': {
// alias: 'v',
// describe: 'Display verbose output',
// default: false,
// type: 'boolean',
// },
// })
.command(
'set [key] [value]',
'Set a configuration value',
(yargs) => {
return yargs.positional('key', {
describe: 'Configuration key to set',
type: 'string',
}).positional('value', {
describe: 'Value to set for the configuration key',
type: 'string',
});
},
(argv) => {
checkConfigExists();
if (!argv.key) throw new Error('key required');
const keys = argv.key.split('.');
const | [current, lastKey] = getConfigValue(config, keys); |
current[lastKey] = argv.value || '';
saveConfig();
}
)
.command(
'use-ai [promptType] [prompts...]',
'Use AI with the specified prompts',
(yargs) => {
return yargs
.positional('promptType', {
describe: 'The type of prompt to use',
default: undefined,
type: 'string',
})
.positional('prompts', {
describe: 'Prompts',
demandOption: true,
type: 'string',
nargs: 1,
array: true,
});
},
async (argv) => {
await spells.useAi(argv.promptType as IPrompts | undefined, ...argv.prompts)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'guided-edit [fileNameWithInstructions] [optionalName]',
'Run guided edit',
(yargs) => {
return yargs
.positional('fileNameWithInstructions', {
describe: 'File name with instructions',
type: 'string',
demandOption: true
})
.positional('optionalName', {
describe: 'Optional name',
type: 'string',
})
.options({
'commit': {
type: 'boolean',
description: 'Will commit edits to the generated branch',
default: true,
},
'pull-request': {
type: 'boolean',
description: 'Will create and add to 1 pull request per generated branch',
default: true,
},
});
},
async (argv) => {
await spells.guidedEdit(argv.fileNameWithInstructions, argv.optionalName)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'file-editor <fileName> [instructions...]',
'Edit any file',
(yargs) => {
return yargs
.positional('fileName', {
describe: 'File Name',
type: 'string',
demandOption: true
})
.positional('instructions', {
describe: 'File name with instructions',
type: 'string',
array: true,
demandOption: true
});
},
async (argv) => {
await spells.fileEditor(argv.fileName, ...argv.instructions)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-component [description]',
'Create a component',
(yargs) => {
return yargs
.positional('description', {
describe: 'Component description',
demandOption: true,
type: 'string',
});
},
async (argv) => {
await spells.createComponent(argv.description)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-api [typeName]',
'Create an API',
(yargs) => {
return yargs
.positional('typeName', {
describe: 'API type name',
demandOption: true,
type: 'string',
});
},
async (argv) => {
const generatedType = await spells.createType(argv.typeName)
await spells.createApi(argv.typeName, generatedType)
.then((result) => console.log(result))
.catch((error) => console.error(error));
await spells.createApiBackend(argv.typeName, generatedType);
}
)
.demandCommand(1, 'You need at least one command before moving on')
.help()
.alias('h', 'help')
.strict();
(async () => {
await parser.argv;
})(); | src/server/cli.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Helper function\nexport function getConfigValue(config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] {\n let current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config;\n for (let i = 0; i < keys.length - 1; i++) {\n if (!isConfigNestedObject(current[keys[i]])) {\n throw new Error('invalid config key');\n }\n current = current[keys[i]] as Record<string, ConfigPropTypes>;\n }\n return [current, keys[keys.length - 1]];",
"score": 45.38611363123588
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// }\n// export function walkNode(rootNode: SyntaxNode) {\n// const linearText: Record<number, string> = {};\n// const nodes: SyntaxNode[] = [];\n// function innerWalk (node: SyntaxNode) {\n// for (const child of node.children) {\n// const key = child.startPosition.row;\n// if (!linearText[key]) {\n// linearText[key] = \"\";\n// }",
"score": 28.301287794385104
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n if (Array.isArray(obj)) {\n return obj.map((item) => deepClone(item) as T) as unknown as T;\n }\n const result: Record<string, unknown> = {};\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = deepClone((obj as Record<string, unknown>)[key]);",
"score": 27.019183968406644
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " const edit = key && editedLines[key as keyof typeof editedLines];\n if (edit) {\n return edit.replace(regex, ''); \n }\n return l.slice(match?match[0].length:0);\n }).filter(l => l?.length > 0).join('\\n');\n console.log({ lined, editedLines, editedFile, editNum: Object.keys(editedLines).length });\n const saved = saveTargetFile(fileName, editedFile);\n return saved;\n}",
"score": 26.16400470058798
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// linearText[key] += (linearText[key] ? \" \" : \"\") + child.text;\n// // Recursion for deeper levels\n// if (child.children && child.children.length > 0 && !linearText[key].includes(child.children[0].text)) {\n// innerWalk(child);\n// }\n// }\n// }\n// innerWalk(rootNode)\n// return nodes;\n// }",
"score": 23.51114200203039
}
] | typescript | [current, lastKey] = getConfigValue(config, keys); |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
| const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {}); |
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " if (!originalFileContents) throw 'File not found.';\n const lined = originalFileContents.split('\\n').map((l, i) => `${i + 1}. ${l}`);\n console.log({ lined, fileName, suggestedEdits });\n const response = await useAi<FileEditorResponse>(IPrompts.FILE_EDITOR, fileName, suggestedEdits.join(' '), lined.join('\\n'));\n console.log({ EDITOR_FINISHED: response.message });\n const editedLines: Record<string, string> = response.message.split('\\n').reduce((m, d) => {\n const match = d.match(/^\\d+. /);\n if (match) {\n console.log({ match })\n return ({",
"score": 37.232012815148096
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 32.089702687573634
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\\$\\{prompt${i + 1}\\}`]: t }), {});\n const promptTemplate = aiPrompts[promptType];\n if (!promptTemplate) throw new Error('invalid prompt type');\n const originalPromptTemplate = JSON.stringify(promptTemplate);\n const completionStringOrMessageHistory = promptTemplate;\n if ('string' === typeof completionStringOrMessageHistory) {\n let completionString = String(completionStringOrMessageHistory);\n for (const token in promptTokens) {\n completionString = completionString.replaceAll(token, promptTokens[token]);\n }",
"score": 28.848117932892215
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " ...m,\n [match[0].trim()]: d.slice(match[0].length)\n })\n }\n return { ...m };\n }, {});\n const regex = /\\/\\*\\s*change:.*?\\*\\//gs;\n const editedFile = lined.map(l => {\n const match = l.match(/^\\d+. /);\n const key = match && match[0].trim();",
"score": 27.724900722173714
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;\nexport type GuidedEditResponse = Record<GuidedEditKeys, string>[];\nexport function isGuidedEditResult(obj: GuardValidations): boolean {\n return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {\n const guidedEditKey = new RegExp(`^${test}_\\\\d+$`);\n return hasSimilarKey(item, guidedEditKey)\n }));\n}",
"score": 26.854197973516825
}
] | typescript | const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {}); |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory = deepClone(completionStringOrMessageHistory);
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest | (request: OpenAIRequestShapes): Promise<string | boolean | undefined> { |
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if (isChatRequest(request)) {
const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
} else if (isCompletionRequest(request)) {
const completionResponse = await openai.createCompletion(request, openAIRequestOptions);
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
} else if (isModerationRequest(request)) {
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": "import { parseChatAttempt } from '../parser';\nimport { IPrompts } from '../../lib/prompts';\nimport { buildOpenAIRequest, performRequest } from '../request';\nimport { logAiResult } from '../stats';\nimport { getConfig } from '../config';\nimport type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';\nimport { isCompletionRequest } from '../util';\nexport async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {\n const config = getConfig();\n const retries = parseInt(config.ai.retries, 10);",
"score": 21.730118737316495
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " })\n } else if (!ignoredStatements.includes(child.getKind())) {\n parsedStatements[statementName] = getStatementText(child);\n originalStatements.set(statementName, getStatementText(child));\n }\n}\nexport async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {\n const config = getConfig();\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')",
"score": 16.673687436302348
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const responseTry = await performRequest(builtRequest);\n aiResponse.rawResponses.push(responseTry);\n if ('undefined' === typeof responseTry) {\n const noChoices = 'Open AI returned no choices.'\n aiResponse.failures.push(noChoices);\n throw new Error(noChoices);\n }\n if ('boolean' === typeof responseTry) {\n const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };\n console.log('MODERATION RESPONSE :==: ', moderationResponse)",
"score": 15.373946482656608
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " 'dist',\n 'build',\n '.git',\n '.svn',\n // add other directories to exclude\n];\nexport function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest {\n return 'messages' in obj;\n}\nexport function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {",
"score": 15.208751785470547
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Helper function\nexport function getConfigValue(config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] {\n let current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config;\n for (let i = 0; i < keys.length - 1; i++) {\n if (!isConfigNestedObject(current[keys[i]])) {\n throw new Error('invalid config key');\n }\n current = current[keys[i]] as Record<string, ConfigPropTypes>;\n }\n return [current, keys[keys.length - 1]];",
"score": 14.920877169954341
}
] | typescript | (request: OpenAIRequestShapes): Promise<string | boolean | undefined> { |
// config.ts
import fs from 'fs';
import path from 'path';
import type { Config as RootConfig, ConfigPropTypes } from '../lib/types';
import { isConfigNestedObject } from '../lib/util';
export const isCliRunning = process.argv[1].includes('bin/src/cli.js');
export const isCalledWithNpx = process.env.npm_execpath && /npx(-cli\.js)?$/.test(process.env.npm_execpath);
const normalPath = path.join(__dirname, `${isCliRunning ? '../..' : isCalledWithNpx ? process.cwd() : '..'}/config.json`)
const npxPath = path.join(process.cwd(), 'config.json')
export const configFilePath = isCalledWithNpx ? npxPath : normalPath;
// Default configuration values
export const defaultConfig = {
ai: { retries: '3', logFile: 'results.json', chatModel: 'gpt-3.5-turbo', completionModel: 'curie' },
ts: { configPath: '', typeDir: '', compDir: '' },
git: { rootPath: '', source: 'main', remote: 'origin' },
user: { name: 'wizapp' }
};
type Config = RootConfig<typeof defaultConfig>;
// Load existing configuration or create a new file with default values
export let config = defaultConfig;
export function checkConfigExists() {
if (fs.existsSync(configFilePath)) {
const rawData = fs.readFileSync(configFilePath);
config = JSON.parse(rawData.toString());
} else {
fs.writeFileSync(configFilePath, JSON.stringify(defaultConfig, null, 2));
config = defaultConfig;
}
}
checkConfigExists();
// Function to save the configuration
export function saveConfig(): void {
fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
}
export function setConfig(newConfig: Config): void {
config = newConfig;
}
export function getConfig(): Config {
return config;
}
export function getConfigFromPath(configPath: string): Config {
let optionalConfig: Config;
try {
const configText = fs.readFileSync(configPath, 'utf-8');
optionalConfig = JSON.parse(configText) as Config;
} catch (error) {
optionalConfig = defaultConfig;
}
return optionalConfig;
}
// Helper function
export function getConfigValue | (config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] { |
let current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config;
for (let i = 0; i < keys.length - 1; i++) {
if (!isConfigNestedObject(current[keys[i]])) {
throw new Error('invalid config key');
}
current = current[keys[i]] as Record<string, ConfigPropTypes>;
}
return [current, keys[keys.length - 1]];
} | src/server/config.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/types.ts",
"retrieved_chunk": "export type ConfigPropTypes = string;\nexport type Config<T = Record<string, Record<string, ConfigPropTypes>>> = T;\nexport type CurrentType = ConfigPropTypes | Config;\nexport type GuardValidations = Record<string, unknown> | Record<string, unknown>[] | string\nexport type OpenAIResults = {\n model?: string;\n timestamp: Date;\n prompts?: string[];\n promptType: string;\n promptTemplate: string | undefined;",
"score": 44.277274216041135
},
{
"filename": "src/tree/modifier.ts",
"retrieved_chunk": "export function createModificationsFunction(): (statement: Statements) => Statements | null {\n const rules = JSON.parse(fs.readFileSync(path.join(__dirname, '../files/mods'), { encoding: 'utf-8' }).toString()) as ModificationRules[];\n return (statement: Statements) => {\n const rule = rules.find((r) => r.type === statement.type);\n if (!rule) {\n return statement;\n }\n switch (rule.action) {\n case 'add':\n return {",
"score": 25.94609543429522
},
{
"filename": "src/lib/index.ts",
"retrieved_chunk": "export * from './prompts';\nexport * from './languages';\nexport * from './util';\nexport type {\n Config,\n ConfigPropTypes,\n GuardValidations,\n ChatResponse,\n CompletionResponse,\n ModerationResponse,",
"score": 25.51351496159638
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 24.4074782947385
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " return JSON.parse(result.toString());\n } catch (error) {\n console.error('Error parsing JSON from extraction script:', error);\n return [];\n }\n}\nexport function copyContentsToDocker(fileName: string, content: string) {\n const tempContentPath = getTempFilePath(fileName, content);\n execSync(`docker cp ${tempContentPath} ${containerName}:/app/${fileName}`)\n}",
"score": 23.61636526912133
}
] | typescript | (config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] { |
import fs from 'fs';
import path from "path";
import { sync } from 'fast-glob';
import { isCalledWithNpx, isCliRunning } from "./config";
import languages from "../lib/languages";
import type { OpenAIRequestShapes } from './types';
import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from 'openai';
const langValues = Object.values(languages);
export const codeGPTPrecursor = 'You are BacktickGPT, providing only typescript code responses wrapped with 3 backticks before and after.';
export function deepClone<T>(obj: T): T {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map((item) => deepClone(item) as T) as unknown as T;
}
const result: Record<string, unknown> = {};
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = deepClone((obj as Record<string, unknown>)[key]);
}
}
return result as T;
}
export const isValidName = (name: string): boolean => {
const regex = /^I[A-Z][a-zA-Z]*$/;
return regex.test(name);
};
export const toSnakeCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);
};
export const toTitleCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
};
export function extractCodeBlock(inputString: string, delimeter: string = '```', languages: string[] = ['typescript', 'json', 'jsx', 'tsx']) {
const langStartTag = (language: string) => language ? `${delimeter}${language}` : delimeter;
for (const language of languages) {
const startTag = langStartTag(language);
if (inputString.includes(startTag)) {
return {
codeBlock: inputString.split(startTag)[1].split(delimeter)[0],
index: inputString.indexOf(startTag) + startTag.length,
};
}
}
if (inputString.includes(delimeter)) {
const index = inputString.indexOf(delimeter) + delimeter.length;
return {
codeBlock: inputString.split(delimeter)[1],
index,
};
}
return {
codeBlock: inputString,
index: 0,
};
};
export function extractCodeBlockPre(inputString: string, index: number): string {
return inputString.substring(0, index)?.trim() || '';
}
export function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {
return inputString.substring(index).split(delimeter)[1]?.trim() || '';
}
export function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {
const { codeBlock, index } = extractCodeBlock(inputString);
const preText = extractCodeBlockPre(inputString, index);
const postText = extractCodeBlockPost(inputString, index);
return {
codeBlock,
supportingText: preText + ' ' + postText,
};
}
export function stripWrappedCharacter(inputString: string, wrappedCharacters: string[] = ['"', "'"]): string {
for (const char of wrappedCharacters) {
if (inputString.startsWith(char)) inputString = inputString.slice(1);
if (inputString.endsWith(char)) inputString = inputString.substring(0, inputString.length - 1);
}
return inputString;
}
export function sanitizeName(input: string): string {
// Trim whitespaces and replace consecutive spaces with a single dash
const trimmed = input.trim();
// Remove invalid characters: ~ ^ : ? * [ ] @ { } \ /
const sanitized = trimmed.replace(/[~^:?"*\[\]@{}\\/]+/g, '');
// Limit branch name length to 100 characters
const maxLength = 100;
const shortened = sanitized.slice(0, maxLength);
// Remove leading and trailing period (.)
const noLeadingTrailingPeriods = shortened.replace(/(^\.+|\.+$)/g, '');
// Remove leading and trailing forward slash (-)
const result = noLeadingTrailingPeriods.replace(/(^-+|-+$)/g, '');
return result;
}
export function ensureKeysAreQuoted(jsonString: string): string {
const unquotedKeysRegex = /([{,]\s*)(\w+)\s*:/g;
function quoteKeys(match: unknown, prefix: string, key: string) {
return `${prefix}"${key}":`;
}
return jsonString.replace(unquotedKeysRegex, quoteKeys);
}
export function typeDefinitionToSentence(typeDefinition: string): string {
const typeNameMatch = typeDefinition.match(/export type (\w+)/);
if (!typeNameMatch) {
return 'Invalid type definition provided.';
}
const typeName = typeNameMatch[1];
const properties = [];
const propertyRegex = /(\w+)\s*:\s*([^;]+);/g;
let match;
while ((match = propertyRegex.exec(typeDefinition)) !== null) {
properties.push({ key: match[1], type: match[2].trim().replace(/\s+/g, ' ') });
}
if (properties.length > 0) {
const propertiesDescription = properties
.map((property) => `${property.key} as a ${property.type}`)
.join(', ');
return `${typeName} defines ${propertiesDescription}.`;
} else {
const recordMatch = typeDefinition.match(/Record<(.+),\s*(.+)>/);
if (recordMatch) {
return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;
}
}
return 'Unable to parse the type definition.';
}
export function getDirPathOf(filePath: string) {
return path.dirname(filePath)
}
export function generateTempFilePath(dir: string, name: string) {
return path.join(dir, `${name}-${Date.now()}.json`)
}
export function getRootDir() {
| return isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../'); |
}
export function getPathOf(name: string, baseDir?: string): string {
return path.join(baseDir || getRootDir(), name);
}
export function getFileParser(fileName: string) {
const extension = path.extname(fileName);
const parser = langValues.find(l => l.fileExtension.includes(extension));
if (!parser) throw 'That parser is undefined!';
return parser.parserName;
}
export function getFileFromDir(file: string, dir: string = __dirname) {
const files = fs.readdirSync(dir);
const fileName = files.find(f => f.startsWith(file));
if (!fileName) throw 'File not found.';
return fs.readFileSync(path.join(dir, fileName), { encoding: 'utf-8' })
}
export function getTargetFile(targetFile: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string | null {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return files.length > 0 ? fileContent : null;
}
export function saveTargetFile(targetFile: string, contents: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.writeFileSync(files[0], contents, { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return 'file saved';
}
const excludeDirectories = [
'node_modules',
'vendor',
'dist',
'build',
'.git',
'.svn',
// add other directories to exclude
];
export function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest {
return 'messages' in obj;
}
export function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {
return 'prompt' in obj;
}
export function isModerationRequest(obj: OpenAIRequestShapes): obj is CreateModerationRequest {
return 'input' in obj;
} | src/server/util.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// config.ts\nimport fs from 'fs';\nimport path from 'path';\nimport type { Config as RootConfig, ConfigPropTypes } from '../lib/types';\nimport { isConfigNestedObject } from '../lib/util';\nexport const isCliRunning = process.argv[1].includes('bin/src/cli.js');\nexport const isCalledWithNpx = process.env.npm_execpath && /npx(-cli\\.js)?$/.test(process.env.npm_execpath);\nconst normalPath = path.join(__dirname, `${isCliRunning ? '../..' : isCalledWithNpx ? process.cwd() : '..'}/config.json`)\nconst npxPath = path.join(process.cwd(), 'config.json')\nexport const configFilePath = isCalledWithNpx ? npxPath : normalPath;",
"score": 55.551267257664506
},
{
"filename": "src/tree/modifier.ts",
"retrieved_chunk": "export function createModificationsFunction(): (statement: Statements) => Statements | null {\n const rules = JSON.parse(fs.readFileSync(path.join(__dirname, '../files/mods'), { encoding: 'utf-8' }).toString()) as ModificationRules[];\n return (statement: Statements) => {\n const rule = rules.find((r) => r.type === statement.type);\n if (!rule) {\n return statement;\n }\n switch (rule.action) {\n case 'add':\n return {",
"score": 34.01090714839107
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " const tempFilePath = path.join(tempDir, fileName);\n fs.writeFileSync(tempFilePath, content);\n return tempFilePath;\n}\nfunction containerExists(): boolean {\n try {\n execSync(`docker inspect ${containerName}`);\n return true;\n } catch (error) {\n return false;",
"score": 29.856032579822635
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " }\n }\n });\n let responseMessage = '';\n if (fileModified) {\n // const projectDiffPath = path.resolve('~/code/project_diff');\n // const apiPath = path.join(projectDiffPath, 'api');\n // const tsConfigFilePath = path.join(apiPath, 'projectts.json');\n // const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);\n // const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)",
"score": 28.442415019355977
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 24.203571844723303
}
] | typescript | return isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../'); |
#!/usr/bin/env node
import yargs from 'yargs/yargs';
import { config, saveConfig, getConfigValue, checkConfigExists } from './config';
import * as spells from './spells';
import { IPrompts } from '../lib/prompts';
const parser = yargs(process.argv.slice(2))
// .options({
// 'config': {
// alias: 'c',
// describe: 'Path to the configuration file',
// default: 'config.json',
// type: 'string',
// },
// 'verbose': {
// alias: 'v',
// describe: 'Display verbose output',
// default: false,
// type: 'boolean',
// },
// })
.command(
'set [key] [value]',
'Set a configuration value',
(yargs) => {
return yargs.positional('key', {
describe: 'Configuration key to set',
type: 'string',
}).positional('value', {
describe: 'Value to set for the configuration key',
type: 'string',
});
},
(argv) => {
checkConfigExists();
if (!argv.key) throw new Error('key required');
const keys = argv.key.split('.');
const [current, lastKey] = getConfigValue(config, keys);
current[lastKey] = argv.value || '';
saveConfig();
}
)
.command(
'use-ai [promptType] [prompts...]',
'Use AI with the specified prompts',
(yargs) => {
return yargs
.positional('promptType', {
describe: 'The type of prompt to use',
default: undefined,
type: 'string',
})
.positional('prompts', {
describe: 'Prompts',
demandOption: true,
type: 'string',
nargs: 1,
array: true,
});
},
async (argv) => {
await spells.useAi(argv.promptType as IPrompts | undefined, ...argv.prompts)
.then((result) => console.log(result))
| .catch((error) => console.error(error)); |
}
)
.command(
'guided-edit [fileNameWithInstructions] [optionalName]',
'Run guided edit',
(yargs) => {
return yargs
.positional('fileNameWithInstructions', {
describe: 'File name with instructions',
type: 'string',
demandOption: true
})
.positional('optionalName', {
describe: 'Optional name',
type: 'string',
})
.options({
'commit': {
type: 'boolean',
description: 'Will commit edits to the generated branch',
default: true,
},
'pull-request': {
type: 'boolean',
description: 'Will create and add to 1 pull request per generated branch',
default: true,
},
});
},
async (argv) => {
await spells.guidedEdit(argv.fileNameWithInstructions, argv.optionalName)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'file-editor <fileName> [instructions...]',
'Edit any file',
(yargs) => {
return yargs
.positional('fileName', {
describe: 'File Name',
type: 'string',
demandOption: true
})
.positional('instructions', {
describe: 'File name with instructions',
type: 'string',
array: true,
demandOption: true
});
},
async (argv) => {
await spells.fileEditor(argv.fileName, ...argv.instructions)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-component [description]',
'Create a component',
(yargs) => {
return yargs
.positional('description', {
describe: 'Component description',
demandOption: true,
type: 'string',
});
},
async (argv) => {
await spells.createComponent(argv.description)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-api [typeName]',
'Create an API',
(yargs) => {
return yargs
.positional('typeName', {
describe: 'API type name',
demandOption: true,
type: 'string',
});
},
async (argv) => {
const generatedType = await spells.createType(argv.typeName)
await spells.createApi(argv.typeName, generatedType)
.then((result) => console.log(result))
.catch((error) => console.error(error));
await spells.createApiBackend(argv.typeName, generatedType);
}
)
.demandCommand(1, 'You need at least one command before moving on')
.help()
.alias('h', 'help')
.strict();
(async () => {
await parser.argv;
})(); | src/server/cli.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " JSON.parse(innerBlockText);\n }\n } catch (error) {\n const err = error as Error;\n throw new Error('cannot parse json.' + err.message)\n }\n console.log(\"Validating innerblocktext : \", innerBlockText)\n const result = validateTypedResponse<T>(innerBlockText);\n return { message: result, supportingText };\n }",
"score": 35.009438805533705
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n }\n try {\n const generatedApiBackend = await useAi<CreateApiBackendResult>(IPrompts.CREATE_API_BACKEND, generatedType + ' ' + apiEndpoints.join(' '))\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`;\n sourceFile.insertText(sourceFile.getEnd(), `${comment}${generatedApiBackend.message}\\n\\n`);\n sourceFile.fixMissingImports();\n await project.save();\n } catch (error) {\n console.error(error);",
"score": 30.35171753680551
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " return JSON.parse(result.toString());\n } catch (error) {\n console.error('Error parsing JSON from extraction script:', error);\n return [];\n }\n}\nexport function copyContentsToDocker(fileName: string, content: string) {\n const tempContentPath = getTempFilePath(fileName, content);\n execSync(`docker cp ${tempContentPath} ${containerName}:/app/${fileName}`)\n}",
"score": 29.85679145362691
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 26.40839086134223
},
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " await git.checkoutBranch(generatedBranch, config.git.source);\n await git.push(config.git.remote, generatedBranch, ['--set-upstream', generatedBranch])\n } catch (error) {\n const err = error as Error;\n if (err.message.includes('A branch named') && err.message.includes('already exists')) {\n console.log('Checking out existing generated branch ', generatedBranch);\n await git.checkout(generatedBranch);\n console.log('Pulling generated branch.');\n await git.pull(config.git.remote, generatedBranch);\n }",
"score": 26.23047404970567
}
] | typescript | .catch((error) => console.error(error)); |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
const generatedStatements | = res.message.reduce((m, d) => ({ ...m, ...d }), {}); |
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " if (!originalFileContents) throw 'File not found.';\n const lined = originalFileContents.split('\\n').map((l, i) => `${i + 1}. ${l}`);\n console.log({ lined, fileName, suggestedEdits });\n const response = await useAi<FileEditorResponse>(IPrompts.FILE_EDITOR, fileName, suggestedEdits.join(' '), lined.join('\\n'));\n console.log({ EDITOR_FINISHED: response.message });\n const editedLines: Record<string, string> = response.message.split('\\n').reduce((m, d) => {\n const match = d.match(/^\\d+. /);\n if (match) {\n console.log({ match })\n return ({",
"score": 36.10442455050781
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\\$\\{prompt${i + 1}\\}`]: t }), {});\n const promptTemplate = aiPrompts[promptType];\n if (!promptTemplate) throw new Error('invalid prompt type');\n const originalPromptTemplate = JSON.stringify(promptTemplate);\n const completionStringOrMessageHistory = promptTemplate;\n if ('string' === typeof completionStringOrMessageHistory) {\n let completionString = String(completionStringOrMessageHistory);\n for (const token in promptTokens) {\n completionString = completionString.replaceAll(token, promptTokens[token]);\n }",
"score": 27.648004063756087
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 27.433416858540035
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;\nexport type GuidedEditResponse = Record<GuidedEditKeys, string>[];\nexport function isGuidedEditResult(obj: GuardValidations): boolean {\n return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {\n const guidedEditKey = new RegExp(`^${test}_\\\\d+$`);\n return hasSimilarKey(item, guidedEditKey)\n }));\n}",
"score": 26.854197973516825
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " ...m,\n [match[0].trim()]: d.slice(match[0].length)\n })\n }\n return { ...m };\n }, {});\n const regex = /\\/\\*\\s*change:.*?\\*\\//gs;\n const editedFile = lined.map(l => {\n const match = l.match(/^\\d+. /);\n const key = match && match[0].trim();",
"score": 24.65939289571564
}
] | typescript | = res.message.reduce((m, d) => ({ ...m, ...d }), {}); |
import { parseChatAttempt } from '../parser';
import { IPrompts } from '../../lib/prompts';
import { buildOpenAIRequest, performRequest } from '../request';
import { logAiResult } from '../stats';
import { getConfig } from '../config';
import type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';
import { isCompletionRequest } from '../util';
export async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {
const config = getConfig();
const retries = parseInt(config.ai.retries, 10);
const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);
const aiResponse: OpenAIResults = {
timestamp: new Date(),
successful: true,
failures: [],
rawResponses: [],
promptTemplate,
promptType: (!promptType ? 'moderation' : promptType) as IPrompts
}
try {
const responseTry = await performRequest(builtRequest);
aiResponse.rawResponses.push(responseTry);
if ('undefined' === typeof responseTry) {
const noChoices = 'Open AI returned no choices.'
aiResponse.failures.push(noChoices);
throw new Error(noChoices);
}
if ('boolean' === typeof responseTry) {
const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };
console.log('MODERATION RESPONSE :==: ', moderationResponse)
logAiResult<T>({ ...moderationResponse, prompts, model: builtRequest.model });
return moderationResponse as UseAIResponses<T>;
}
if (isCompletionRequest(builtRequest)) {
const completionResponse: CompletionResponse = {
...aiResponse,
message: responseTry
};
console.log('COMPLETION RESPONSE :==: ', completionResponse)
logAiResult<T>({ ...completionResponse, prompts, model: builtRequest.model });
return completionResponse as UseAIResponses<T>;
}
async function resolveAttempt(attempt: string, retriesRemaining: number): Promise<ChatResponse<T>> {
try {
| const { supportingText, message } = parseChatAttempt<T>(attempt); |
const chatResponse = {
...aiResponse,
supportingText,
message
};
logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });
console.log('CHAT RESPONSE :==: ', chatResponse)
return chatResponse;
} catch (error) {
const err = error as Error;
if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {
const repeatedAttempt = await performRequest(builtRequest);
aiResponse.rawResponses.push(repeatedAttempt);
if ('string' !== typeof repeatedAttempt) {
const imparsable = 'Received imparsable resolution during retry.';
aiResponse.failures.push(imparsable);
throw new Error(imparsable);
}
return await resolveAttempt(repeatedAttempt, retriesRemaining - 1);
}
const resolveIssue = 'Critical chat parse error or could not resolve a valid response after ' + retries + ' attempts. ' + (err.message ? 'Parsing error: ' + err.message : '');
aiResponse.failures.push(resolveIssue);
throw new Error(resolveIssue);
}
}
return await resolveAttempt(responseTry, retries) as UseAIResponses<T>;
} catch (error) {
const err = error as Error;
aiResponse.successful = false;
logAiResult({ ...aiResponse, prompts, message: err.message + ' ' + err.stack, model: builtRequest.model });
throw new Error('General use AI failure!\nStack: ' + err.stack);
}
}
| src/server/spells/use_ai_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " attempt = stripWrappedCharacter(attempt);\n console.log(\"Parsing a basic attempt: \", attempt);\n const result = validateTypedResponse<T>(attempt);\n return { message: result, supportingText: '' };\n}\nexport let responseValidators = [\n isConvertPurposeResult,\n isFileEditorResult,\n isGuidedEditResult,\n isCreateTypeResponse,",
"score": 44.522431784690504
},
{
"filename": "src/lib/types.ts",
"retrieved_chunk": " rawResponses: (string | boolean | undefined)[];\n failures: string[];\n successful: boolean;\n}\nexport type ChatResponse<T> = OpenAIResults & {\n supportingText?: string;\n message: T;\n}\nexport type CompletionResponse = OpenAIResults & {\n message: string;",
"score": 37.052621913542204
},
{
"filename": "src/server/parser.ts",
"retrieved_chunk": "import { isConvertPurposeResult } from \"../lib/prompts/convert_purpose_prompt\";\nimport { isCreateApiBackendResult } from \"../lib/prompts/create_api_backend_prompt\";\nimport { isCreateApiResult } from \"../lib/prompts/create_api_prompt\";\nimport { isGeneralComponentResponse } from \"../lib/prompts/create_gen_component_prompt\";\nimport { isCreateTypeResponse } from \"../lib/prompts/create_type_prompt\";\nimport { isFileEditorResult } from \"../lib/prompts/file_editor_prompt\";\nimport { isGuidedEditResult } from \"../lib/prompts/guided_edit_prompt\";\nimport type { GuardValidations } from \"../lib/types\";\nimport { processTextWithCodeBlock, stripWrappedCharacter } from \"./util\";\nexport function parseChatAttempt<T>(attempt: string): { supportingText: string, message: T } {",
"score": 36.95668843693073
},
{
"filename": "src/lib/types.ts",
"retrieved_chunk": "}\nexport type ModerationResponse = OpenAIResults & {\n flagged: boolean;\n}\nexport type UseAIResponses<T> = T extends boolean ? ModerationResponse : T extends undefined ? CompletionResponse : ChatResponse<T>;\nexport interface Node {\n type: string;\n text: string;\n children: Node[];\n}",
"score": 32.83800555513658
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const completionResponse = await openai.createCompletion(request, openAIRequestOptions);\n console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });\n return completionResponse.data.choices[0].text?.trim();\n } else if (isModerationRequest(request)) {\n const moderationResponse = await openai.createModeration(request, openAIRequestOptions);\n console.log({ RAW_MODERATION: moderationResponse.data.results[0] });\n return moderationResponse.data.results[0]?.flagged;\n }\n}",
"score": 32.29562305786836
}
] | typescript | const { supportingText, message } = parseChatAttempt<T>(attempt); |
// import fs from 'fs';
// import { Node, Project, ScriptKind, SyntaxKind } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { getConfig } from '../config';
// import { getPathOf, sanitizeName } from '../util';
import { FileEditorResponse } from '../../lib/prompts/file_editor_prompt';
import { getTargetFile, saveTargetFile } from '../util';
// import { copyContentsToDocker } from '../tree/docker';
export async function fileEditor(...fileParts: string[]): Promise<string> {
console.log({ fileParts });
const config = getConfig();
if (!config.ts.compDir) {
throw new Error('Missing ts.compDir.')
}
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const [fileName, ...suggestedEdits] = fileParts;
const originalFileContents = getTargetFile(fileName, config.git.rootPath);
if (!originalFileContents) throw 'File not found.';
const lined = originalFileContents.split('\n').map((l, i) => `${i + 1}. ${l}`);
console.log({ lined, fileName, suggestedEdits });
const response = await useAi<FileEditorResponse>(IPrompts.FILE_EDITOR, fileName, suggestedEdits.join(' '), lined.join('\n'));
console.log({ EDITOR_FINISHED: response.message });
const editedLines: Record<string, string> = response.message.split('\n').reduce((m, d) => {
const match = d.match(/^\d+. /);
if (match) {
console.log({ match })
return ({
...m,
[match[0].trim()]: d.slice(match[0].length)
})
}
return { ...m };
}, {});
const regex = /\/\*\s*change:.*?\*\//gs;
const editedFile = lined.map(l => {
const match = l.match(/^\d+. /);
const key = match && match[0].trim();
const edit = key && editedLines[key as keyof typeof editedLines];
if (edit) {
return edit.replace(regex, '');
}
return l.slice(match?match[0].length:0);
}).filter(l => l?.length > 0).join('\n');
console.log({ lined, editedLines, editedFile, editNum: Object.keys(editedLines).length });
| const saved = saveTargetFile(fileName, editedFile); |
return saved;
} | src/server/spells/file_editor_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/util.ts",
"retrieved_chunk": " }\n const typeName = typeNameMatch[1];\n const properties = [];\n const propertyRegex = /(\\w+)\\s*:\\s*([^;]+);/g;\n let match;\n while ((match = propertyRegex.exec(typeDefinition)) !== null) {\n properties.push({ key: match[1], type: match[2].trim().replace(/\\s+/g, ' ') });\n }\n if (properties.length > 0) {\n const propertiesDescription = properties",
"score": 85.8625564462257
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " const unquotedKeysRegex = /([{,]\\s*)(\\w+)\\s*:/g;\n function quoteKeys(match: unknown, prefix: string, key: string) {\n return `${prefix}\"${key}\":`;\n }\n return jsonString.replace(unquotedKeysRegex, quoteKeys);\n}\nexport function typeDefinitionToSentence(typeDefinition: string): string {\n const typeNameMatch = typeDefinition.match(/export type (\\w+)/);\n if (!typeNameMatch) {\n return 'Invalid type definition provided.';",
"score": 58.58472856609956
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " throw new Error(\"Invalid name format\");\n }\n return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);\n};\nexport const toTitleCase = (name: string): string => {\n if (!isValidName(name)) {\n throw new Error(\"Invalid name format\");\n }\n return name.substr(1).replace(/([A-Z])/g, \" $1\").replace(/^./, (str) => str.toUpperCase());\n};",
"score": 47.33918798831687
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " .map((property) => `${property.key} as a ${property.type}`)\n .join(', ');\n return `${typeName} defines ${propertiesDescription}.`;\n } else {\n const recordMatch = typeDefinition.match(/Record<(.+),\\s*(.+)>/);\n if (recordMatch) {\n return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;\n }\n }\n return 'Unable to parse the type definition.';",
"score": 45.87393272443387
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// linearText[key] += (linearText[key] ? \" \" : \"\") + child.text;\n// // Recursion for deeper levels\n// if (child.children && child.children.length > 0 && !linearText[key].includes(child.children[0].text)) {\n// innerWalk(child);\n// }\n// }\n// }\n// innerWalk(rootNode)\n// return nodes;\n// }",
"score": 41.91161272785823
}
] | typescript | const saved = saveTargetFile(fileName, editedFile); |
// config.ts
import fs from 'fs';
import path from 'path';
import type { Config as RootConfig, ConfigPropTypes } from '../lib/types';
import { isConfigNestedObject } from '../lib/util';
export const isCliRunning = process.argv[1].includes('bin/src/cli.js');
export const isCalledWithNpx = process.env.npm_execpath && /npx(-cli\.js)?$/.test(process.env.npm_execpath);
const normalPath = path.join(__dirname, `${isCliRunning ? '../..' : isCalledWithNpx ? process.cwd() : '..'}/config.json`)
const npxPath = path.join(process.cwd(), 'config.json')
export const configFilePath = isCalledWithNpx ? npxPath : normalPath;
// Default configuration values
export const defaultConfig = {
ai: { retries: '3', logFile: 'results.json', chatModel: 'gpt-3.5-turbo', completionModel: 'curie' },
ts: { configPath: '', typeDir: '', compDir: '' },
git: { rootPath: '', source: 'main', remote: 'origin' },
user: { name: 'wizapp' }
};
type Config = RootConfig<typeof defaultConfig>;
// Load existing configuration or create a new file with default values
export let config = defaultConfig;
export function checkConfigExists() {
if (fs.existsSync(configFilePath)) {
const rawData = fs.readFileSync(configFilePath);
config = JSON.parse(rawData.toString());
} else {
fs.writeFileSync(configFilePath, JSON.stringify(defaultConfig, null, 2));
config = defaultConfig;
}
}
checkConfigExists();
// Function to save the configuration
export function saveConfig(): void {
fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
}
export function setConfig(newConfig: Config): void {
config = newConfig;
}
export function getConfig(): Config {
return config;
}
export function getConfigFromPath(configPath: string): Config {
let optionalConfig: Config;
try {
const configText = fs.readFileSync(configPath, 'utf-8');
optionalConfig = JSON.parse(configText) as Config;
} catch (error) {
optionalConfig = defaultConfig;
}
return optionalConfig;
}
// Helper function
export function getConfigValue(config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] {
let current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config;
for (let i = 0; i < keys.length - 1; i++) {
if ( | !isConfigNestedObject(current[keys[i]])) { |
throw new Error('invalid config key');
}
current = current[keys[i]] as Record<string, ConfigPropTypes>;
}
return [current, keys[keys.length - 1]];
} | src/server/config.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/types.ts",
"retrieved_chunk": "export type ConfigPropTypes = string;\nexport type Config<T = Record<string, Record<string, ConfigPropTypes>>> = T;\nexport type CurrentType = ConfigPropTypes | Config;\nexport type GuardValidations = Record<string, unknown> | Record<string, unknown>[] | string\nexport type OpenAIResults = {\n model?: string;\n timestamp: Date;\n prompts?: string[];\n promptType: string;\n promptTemplate: string | undefined;",
"score": 64.95393439210098
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 46.224489361244466
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " parsedStatementText = parent.getText();\n }\n return parsedStatementText;\n}\nconst ignoredStatements = [SyntaxKind.TryStatement]\nfunction walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {\n const statementName = `statement_${i}`;\n if (child instanceof FunctionDeclaration) {\n child.getStatements().forEach((descendant, index) => {\n walkNode(descendant, index + i, parsedStatements, originalStatements);",
"score": 45.39481034579648
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\\$\\{prompt${i + 1}\\}`]: t }), {});\n const promptTemplate = aiPrompts[promptType];\n if (!promptTemplate) throw new Error('invalid prompt type');\n const originalPromptTemplate = JSON.stringify(promptTemplate);\n const completionStringOrMessageHistory = promptTemplate;\n if ('string' === typeof completionStringOrMessageHistory) {\n let completionString = String(completionStringOrMessageHistory);\n for (const token in promptTokens) {\n completionString = completionString.replaceAll(token, promptTokens[token]);\n }",
"score": 43.78976441181314
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " });\n },\n (argv) => {\n checkConfigExists();\n if (!argv.key) throw new Error('key required');\n const keys = argv.key.split('.');\n const [current, lastKey] = getConfigValue(config, keys);\n current[lastKey] = argv.value || '';\n saveConfig();\n }",
"score": 41.16614502955367
}
] | typescript | !isConfigNestedObject(current[keys[i]])) { |
import fs from 'fs';
import path from "path";
import { sync } from 'fast-glob';
import { isCalledWithNpx, isCliRunning } from "./config";
import languages from "../lib/languages";
import type { OpenAIRequestShapes } from './types';
import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from 'openai';
const langValues = Object.values(languages);
export const codeGPTPrecursor = 'You are BacktickGPT, providing only typescript code responses wrapped with 3 backticks before and after.';
export function deepClone<T>(obj: T): T {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map((item) => deepClone(item) as T) as unknown as T;
}
const result: Record<string, unknown> = {};
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = deepClone((obj as Record<string, unknown>)[key]);
}
}
return result as T;
}
export const isValidName = (name: string): boolean => {
const regex = /^I[A-Z][a-zA-Z]*$/;
return regex.test(name);
};
export const toSnakeCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);
};
export const toTitleCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
};
export function extractCodeBlock(inputString: string, delimeter: string = '```', languages: string[] = ['typescript', 'json', 'jsx', 'tsx']) {
const langStartTag = (language: string) => language ? `${delimeter}${language}` : delimeter;
for (const language of languages) {
const startTag = langStartTag(language);
if (inputString.includes(startTag)) {
return {
codeBlock: inputString.split(startTag)[1].split(delimeter)[0],
index: inputString.indexOf(startTag) + startTag.length,
};
}
}
if (inputString.includes(delimeter)) {
const index = inputString.indexOf(delimeter) + delimeter.length;
return {
codeBlock: inputString.split(delimeter)[1],
index,
};
}
return {
codeBlock: inputString,
index: 0,
};
};
export function extractCodeBlockPre(inputString: string, index: number): string {
return inputString.substring(0, index)?.trim() || '';
}
export function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {
return inputString.substring(index).split(delimeter)[1]?.trim() || '';
}
export function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {
const { codeBlock, index } = extractCodeBlock(inputString);
const preText = extractCodeBlockPre(inputString, index);
const postText = extractCodeBlockPost(inputString, index);
return {
codeBlock,
supportingText: preText + ' ' + postText,
};
}
export function stripWrappedCharacter(inputString: string, wrappedCharacters: string[] = ['"', "'"]): string {
for (const char of wrappedCharacters) {
if (inputString.startsWith(char)) inputString = inputString.slice(1);
if (inputString.endsWith(char)) inputString = inputString.substring(0, inputString.length - 1);
}
return inputString;
}
export function sanitizeName(input: string): string {
// Trim whitespaces and replace consecutive spaces with a single dash
const trimmed = input.trim();
// Remove invalid characters: ~ ^ : ? * [ ] @ { } \ /
const sanitized = trimmed.replace(/[~^:?"*\[\]@{}\\/]+/g, '');
// Limit branch name length to 100 characters
const maxLength = 100;
const shortened = sanitized.slice(0, maxLength);
// Remove leading and trailing period (.)
const noLeadingTrailingPeriods = shortened.replace(/(^\.+|\.+$)/g, '');
// Remove leading and trailing forward slash (-)
const result = noLeadingTrailingPeriods.replace(/(^-+|-+$)/g, '');
return result;
}
export function ensureKeysAreQuoted(jsonString: string): string {
const unquotedKeysRegex = /([{,]\s*)(\w+)\s*:/g;
function quoteKeys(match: unknown, prefix: string, key: string) {
return `${prefix}"${key}":`;
}
return jsonString.replace(unquotedKeysRegex, quoteKeys);
}
export function typeDefinitionToSentence(typeDefinition: string): string {
const typeNameMatch = typeDefinition.match(/export type (\w+)/);
if (!typeNameMatch) {
return 'Invalid type definition provided.';
}
const typeName = typeNameMatch[1];
const properties = [];
const propertyRegex = /(\w+)\s*:\s*([^;]+);/g;
let match;
while ((match = propertyRegex.exec(typeDefinition)) !== null) {
properties.push({ key: match[1], type: match[2].trim().replace(/\s+/g, ' ') });
}
if (properties.length > 0) {
const propertiesDescription = properties
.map((property) => `${property.key} as a ${property.type}`)
.join(', ');
return `${typeName} defines ${propertiesDescription}.`;
} else {
const recordMatch = typeDefinition.match(/Record<(.+),\s*(.+)>/);
if (recordMatch) {
return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;
}
}
return 'Unable to parse the type definition.';
}
export function getDirPathOf(filePath: string) {
return path.dirname(filePath)
}
export function generateTempFilePath(dir: string, name: string) {
return path.join(dir, `${name}-${Date.now()}.json`)
}
export function getRootDir() {
return | isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../'); |
}
export function getPathOf(name: string, baseDir?: string): string {
return path.join(baseDir || getRootDir(), name);
}
export function getFileParser(fileName: string) {
const extension = path.extname(fileName);
const parser = langValues.find(l => l.fileExtension.includes(extension));
if (!parser) throw 'That parser is undefined!';
return parser.parserName;
}
export function getFileFromDir(file: string, dir: string = __dirname) {
const files = fs.readdirSync(dir);
const fileName = files.find(f => f.startsWith(file));
if (!fileName) throw 'File not found.';
return fs.readFileSync(path.join(dir, fileName), { encoding: 'utf-8' })
}
export function getTargetFile(targetFile: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string | null {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return files.length > 0 ? fileContent : null;
}
export function saveTargetFile(targetFile: string, contents: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.writeFileSync(files[0], contents, { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return 'file saved';
}
const excludeDirectories = [
'node_modules',
'vendor',
'dist',
'build',
'.git',
'.svn',
// add other directories to exclude
];
export function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest {
return 'messages' in obj;
}
export function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {
return 'prompt' in obj;
}
export function isModerationRequest(obj: OpenAIRequestShapes): obj is CreateModerationRequest {
return 'input' in obj;
} | src/server/util.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// config.ts\nimport fs from 'fs';\nimport path from 'path';\nimport type { Config as RootConfig, ConfigPropTypes } from '../lib/types';\nimport { isConfigNestedObject } from '../lib/util';\nexport const isCliRunning = process.argv[1].includes('bin/src/cli.js');\nexport const isCalledWithNpx = process.env.npm_execpath && /npx(-cli\\.js)?$/.test(process.env.npm_execpath);\nconst normalPath = path.join(__dirname, `${isCliRunning ? '../..' : isCalledWithNpx ? process.cwd() : '..'}/config.json`)\nconst npxPath = path.join(process.cwd(), 'config.json')\nexport const configFilePath = isCalledWithNpx ? npxPath : normalPath;",
"score": 54.83797716368125
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " }\n }\n });\n let responseMessage = '';\n if (fileModified) {\n // const projectDiffPath = path.resolve('~/code/project_diff');\n // const apiPath = path.join(projectDiffPath, 'api');\n // const tsConfigFilePath = path.join(apiPath, 'projectts.json');\n // const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);\n // const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)",
"score": 28.442415019355977
},
{
"filename": "src/tree/modifier.ts",
"retrieved_chunk": "export function createModificationsFunction(): (statement: Statements) => Statements | null {\n const rules = JSON.parse(fs.readFileSync(path.join(__dirname, '../files/mods'), { encoding: 'utf-8' }).toString()) as ModificationRules[];\n return (statement: Statements) => {\n const rule = rules.find((r) => r.type === statement.type);\n if (!rule) {\n return statement;\n }\n switch (rule.action) {\n case 'add':\n return {",
"score": 28.423620492935758
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " const tempFilePath = path.join(tempDir, fileName);\n fs.writeFileSync(tempFilePath, content);\n return tempFilePath;\n}\nfunction containerExists(): boolean {\n try {\n execSync(`docker inspect ${containerName}`);\n return true;\n } catch (error) {\n return false;",
"score": 28.118985817528124
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 21.97775542767773
}
] | typescript | isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../'); |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {});
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const | prRes = await managePullRequest(generatedBranch, prTitle, prBody); |
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n }\n try {\n const generatedApiBackend = await useAi<CreateApiBackendResult>(IPrompts.CREATE_API_BACKEND, generatedType + ' ' + apiEndpoints.join(' '))\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`;\n sourceFile.insertText(sourceFile.getEnd(), `${comment}${generatedApiBackend.message}\\n\\n`);\n sourceFile.fixMissingImports();\n await project.save();\n } catch (error) {\n console.error(error);",
"score": 50.30915691881777
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 37.6765348994855
},
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " const git = simpleGit(config.git.rootPath);\n const generatedBranch = sanitizeName(`gen/${name}`);\n console.log('Prepare branch main checkout.');\n await git.checkout(config.git.source);\n console.log('Pulling main.');\n await git.pull(config.git.remote, config.git.source);\n console.log('Fetching.');\n await git.fetch('all');\n try {\n console.log('Creating a new branch for ', generatedBranch);",
"score": 32.44139194264471
},
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " await git.checkoutBranch(generatedBranch, config.git.source);\n await git.push(config.git.remote, generatedBranch, ['--set-upstream', generatedBranch])\n } catch (error) {\n const err = error as Error;\n if (err.message.includes('A branch named') && err.message.includes('already exists')) {\n console.log('Checking out existing generated branch ', generatedBranch);\n await git.checkout(generatedBranch);\n console.log('Pulling generated branch.');\n await git.pull(config.git.remote, generatedBranch);\n }",
"score": 32.44121921963034
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n if (!config.ts.typeDir) {\n throw new Error('Missing ts.typeDir.');\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const coreTypesPath = sanitizeName(config.ts.typeDir);\n const typeFileName = getPathOf(`${coreTypesPath}/${toSnakeCase(typeName)}.ts`);\n const sourceFile = project.addSourceFileAtPath(typeFileName);",
"score": 28.414298599659407
}
] | typescript | prRes = await managePullRequest(generatedBranch, prTitle, prBody); |
import { parseChatAttempt } from '../parser';
import { IPrompts } from '../../lib/prompts';
import { buildOpenAIRequest, performRequest } from '../request';
import { logAiResult } from '../stats';
import { getConfig } from '../config';
import type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';
import { isCompletionRequest } from '../util';
export async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {
const config = getConfig();
const retries = parseInt(config.ai.retries, 10);
const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);
const aiResponse: OpenAIResults = {
timestamp: new Date(),
successful: true,
failures: [],
rawResponses: [],
promptTemplate,
promptType: (!promptType ? 'moderation' : promptType) as IPrompts
}
try {
const responseTry = await performRequest(builtRequest);
aiResponse.rawResponses.push(responseTry);
if ('undefined' === typeof responseTry) {
const noChoices = 'Open AI returned no choices.'
aiResponse.failures.push(noChoices);
throw new Error(noChoices);
}
if ('boolean' === typeof responseTry) {
const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };
console.log('MODERATION RESPONSE :==: ', moderationResponse)
logAiResult<T>({ ...moderationResponse, prompts, model: builtRequest.model });
return moderationResponse as UseAIResponses<T>;
}
if (isCompletionRequest(builtRequest)) {
const completionResponse: CompletionResponse = {
...aiResponse,
message: responseTry
};
console.log('COMPLETION RESPONSE :==: ', completionResponse)
logAiResult<T>({ ...completionResponse, prompts, model: builtRequest.model });
return completionResponse as UseAIResponses<T>;
}
| async function resolveAttempt(attempt: string, retriesRemaining: number): Promise<ChatResponse<T>> { |
try {
const { supportingText, message } = parseChatAttempt<T>(attempt);
const chatResponse = {
...aiResponse,
supportingText,
message
};
logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });
console.log('CHAT RESPONSE :==: ', chatResponse)
return chatResponse;
} catch (error) {
const err = error as Error;
if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {
const repeatedAttempt = await performRequest(builtRequest);
aiResponse.rawResponses.push(repeatedAttempt);
if ('string' !== typeof repeatedAttempt) {
const imparsable = 'Received imparsable resolution during retry.';
aiResponse.failures.push(imparsable);
throw new Error(imparsable);
}
return await resolveAttempt(repeatedAttempt, retriesRemaining - 1);
}
const resolveIssue = 'Critical chat parse error or could not resolve a valid response after ' + retries + ' attempts. ' + (err.message ? 'Parsing error: ' + err.message : '');
aiResponse.failures.push(resolveIssue);
throw new Error(resolveIssue);
}
}
return await resolveAttempt(responseTry, retries) as UseAIResponses<T>;
} catch (error) {
const err = error as Error;
aiResponse.successful = false;
logAiResult({ ...aiResponse, prompts, message: err.message + ' ' + err.stack, model: builtRequest.model });
throw new Error('General use AI failure!\nStack: ' + err.stack);
}
}
| src/server/spells/use_ai_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const completionResponse = await openai.createCompletion(request, openAIRequestOptions);\n console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });\n return completionResponse.data.choices[0].text?.trim();\n } else if (isModerationRequest(request)) {\n const moderationResponse = await openai.createModeration(request, openAIRequestOptions);\n console.log({ RAW_MODERATION: moderationResponse.data.results[0] });\n return moderationResponse.data.results[0]?.flagged;\n }\n}",
"score": 41.51496286155166
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ModerationResponse } from \"../lib/types\";\nimport fs from 'fs';\nimport { getConfig } from \"./config\";\nimport { isChatResponse, isCompletionResponse, isModerationResponse } from \"../lib/util\";\nexport function logAiResult<T>(res: ChatResponse<T> | CompletionResponse | ModerationResponse) {\n const config = getConfig();\n const { successful, timestamp, failures, rawResponses, prompts, model, ...metric } = res;\n const duration = ((new Date()).getTime() - (new Date(res.timestamp).getTime())) / 1000;\n let metrics: Record<string, unknown> = {\n pass: successful,",
"score": 32.960272245264285
},
{
"filename": "src/lib/types.ts",
"retrieved_chunk": "}\nexport type ModerationResponse = OpenAIResults & {\n flagged: boolean;\n}\nexport type UseAIResponses<T> = T extends boolean ? ModerationResponse : T extends undefined ? CompletionResponse : ChatResponse<T>;\nexport interface Node {\n type: string;\n text: string;\n children: Node[];\n}",
"score": 31.552999190739648
},
{
"filename": "src/lib/types.ts",
"retrieved_chunk": " rawResponses: (string | boolean | undefined)[];\n failures: string[];\n successful: boolean;\n}\nexport type ChatResponse<T> = OpenAIResults & {\n supportingText?: string;\n message: T;\n}\nexport type CompletionResponse = OpenAIResults & {\n message: string;",
"score": 28.9884954341734
},
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " attempt = stripWrappedCharacter(attempt);\n console.log(\"Parsing a basic attempt: \", attempt);\n const result = validateTypedResponse<T>(attempt);\n return { message: result, supportingText: '' };\n}\nexport let responseValidators = [\n isConvertPurposeResult,\n isFileEditorResult,\n isGuidedEditResult,\n isCreateTypeResponse,",
"score": 26.916308544083307
}
] | typescript | async function resolveAttempt(attempt: string, retriesRemaining: number): Promise<ChatResponse<T>> { |
import { ChatCompletionRequestMessage } from "openai";
import type { GuardValidations } from "../types";
// const fileEditorPrompt = [
// { role: 'system', content: 'you are a helpful file editing assistant' },
// { role: 'user', content: 'edit ${prompt1} with regard to ${prompt2}. only show edited lines. remember to encase the edited code inside proper markdown "```" header. \n\n ${prompt1}:\n${prompt3}' }
// ];
export const fileEditorMessages: ChatCompletionRequestMessage[] = [
{ role: 'system', content: 'You, CodeCommenter, follow user instructions to add, edit, and delete text in specific ways, leaving change comments. You only reply with the line number + the change comment + the new content of the line. 3 possible static comments: "/* change: added text */", "/* change: edited text */", and "/* change: fully removed text */". Your reply includes only changed lines which have change comments, and clearly formats it in an anonymous markdown backtick block.' },
// { role: 'system', content: 'You reply with: "I only edited line {number of each edited line}, so I am just going to show you {number of edited lines} lines, including empty lines:"' },
{ role: 'user', content: `add_text_example.txt
instructions: put a happy face on line 4
1. Lorem ipsum dolor sit amet.
2. Lorem ipsum dolor sit amet.
3. Lorem ipsum dolor sit amet.
4. Lorem ipsum dolor sit amet.
5. Lorem ipsum dolor sit amet.
6. Lorem ipsum dolor sit amet.
7. Lorem ipsum dolor sit amet.`},
{ role: 'assistant', content: `1 text change signified: I edited line 4, which is 1 total edited line. Here is the 1 edited line containing a signifier, including its line number:
\`\`\`
4. Lorem ipsum dolor sit amet. :) /* change: added text */
\`\`\`
Please find the 1 change above this line.`},
{ role: 'user', content: `remove_and_edit_text_example.js
instructions: remove any console logs. change ts.configPath to ts.configRoot
1. const config = getConfig();
2. if (!config.ts.compDir) {
3. console.log('hey');
4. throw new Error('Missing ts.compDir.')
5. }
6.
7. if (!config.ts.configPath) {
8. console.log('testing removals');
9. throw new Error('Missing ts.configPath.')
10. }`},
{ role: 'assistant', content: `4 text changes signified: I edited lines 3, 7, 8, and 9, which is 4 total edited lines. Here are the 4 lines containing signifiers, including their line numbers:
\`\`\`
3. /* change: fully removed text */
7. if (!config.ts.configRoot) { /* change: edited text */
8. /* change: fully removed text */
9. throw new Error('Missing ts.configRoot.') /* change: edited text */
\`\`\`
Please find the 4 changes above this line.` },
{ role: 'user', content: `\${prompt1}
\${prompt2}
\${prompt3}`}
];
// const testSystem = 'you are a helpful typescript coding assistant';
// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown "```typescript" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'
const fileEditorResponseRegex = /^\d+./igm;
export type FileEditorResponse = `${number}. ${string}`;
| export function isFileEditorResult(obj: GuardValidations): boolean { |
return 'string' === typeof obj && fileEditorResponseRegex.test(obj);
} | src/lib/prompts/file_editor_prompt.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown \"```typescript\" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'\nexport const guidedEditMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'I change code from a JSON object to an array based on the target state.' },\n { role: 'assistant', content: `What I need:\n JSON object with code statements\n Desired state of the code statements\n What I do:\n Check which statements in the JSON object can help reach the desired state.\n Keep only useful statements.\n Change the statements to reach the target state. I can update, insert, or remove statements.",
"score": 118.60500043472794
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "// @@@\n// &&&\n// Following Steps:\n// Provide the necessary context in the statements for me to carry out the modifications. Use the keywords STATEMENTS_JSON and TARGET_STATE to convey the required inputs:\n// TARGET_STATE --- <an english phrase with some coding terms>\n// STATEMENTS_JSON --- <a plain old javascript object (POJO)>\n// On receiving TARGET_STATE and STATEMENTS_JSON, I'll start whittling away on the STATEMENTS_JSON as needed, to achieve TARGET_STATE, in order to derive RESPONSE_ARRAY.`},\n// { role: 'user', content: ' TARGET_STATE --- ${prompt1}\\n STATEMENTS_JSON --- ${prompt2}' }\n// ];\n// const testSystem = 'you are a helpful typescript coding assistant';",
"score": 58.942891229711186
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\n// const createTypePrompt = 'Complete the following typescript type with 4-7 unconventionally named properties, using string, number or boolean, starting with its opening bracket, \"type ${prompt1} =';\n// const createTypeMessages = [\n// { role: 'system', content: 'I, TypescriptTypeGeneratorGPT, respond with a code statement declaring a Typescript type, based on the name of a type.' },\n// { role: 'assistant', content: `This message describes how \\${prompt1} will be generated and returned in the next message.\n// 1. Parse Name: You provided a name in the format of ITypeName, \\${prompt1}, which I will evaluate to determine its general informational context.\n// 2. Primary Action: Generate TYPE_DEFINITION of 4-7 unconventionally named properties.\n// 3. Primary Validation: TYPE_DEFINITION is validated as starting with text \"type \\${prompt1} = {\" with the rest of TYPE_DEFINITION to follow.\n// 4. Secondary Validation: Exact response text verified to be formatted in the following pattern:",
"score": 49.79719085275223
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": " @@@\n &&&\n Next steps:\n Give me the desired state and JSON object with code statements using these keywords:\n TARGET_STATE --- <phrase with code terms>\n STATEMENTS_JSON --- <a simple JSON object>\n I'll change the code in the JSON object to reach the target state and create the final array.`},\n { role: 'user', content: ' TARGET_STATE --- ${prompt1}\\n STATEMENTS_JSON --- ${prompt2}' }\n];\nexport type GuidedEditKeyPrefix = 'statement' | 'above' | 'below';",
"score": 45.43219528515942
},
{
"filename": "src/lib/prompts/convert_purpose_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\nexport const convertPurposeMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'You respond with a single gerund phrase, 5 to 8 words, which will complete the user\\'s sentence. For example, \"walking in the sunshine with you\".' },\n { role: 'assistant', content: 'Give me an incomplete sentence that I can complete with a gerund phrase. For example, if you said \"Our favorite past time is\", I might respond \"walking in the sunshine with you\"' },\n { role: 'user', content: 'An organization named \"${prompt1}\" is interested in \"${prompt2}\" and their mission statement is' }\n];\nexport type ConvertPurposeResult = string;\nconst convertPurposeRegex = /\\b[a-z]*ing\\b/i;\nexport function isConvertPurposeResult(obj: GuardValidations): obj is ConvertPurposeResult {",
"score": 42.66528876639702
}
] | typescript | export function isFileEditorResult(obj: GuardValidations): boolean { |
import { isConvertPurposeResult } from "../lib/prompts/convert_purpose_prompt";
import { isCreateApiBackendResult } from "../lib/prompts/create_api_backend_prompt";
import { isCreateApiResult } from "../lib/prompts/create_api_prompt";
import { isGeneralComponentResponse } from "../lib/prompts/create_gen_component_prompt";
import { isCreateTypeResponse } from "../lib/prompts/create_type_prompt";
import { isFileEditorResult } from "../lib/prompts/file_editor_prompt";
import { isGuidedEditResult } from "../lib/prompts/guided_edit_prompt";
import type { GuardValidations } from "../lib/types";
import { processTextWithCodeBlock, stripWrappedCharacter } from "./util";
export function parseChatAttempt<T>(attempt: string): { supportingText: string, message: T } {
const aiRefusalError = /(^i\'m sorry)|(?:ai(?:\s|-)?language(?:\s|-)?model|i(?:'?m| am))(?:[^.]*?)(?:can(?:'?t| not)|unable to)(?:[^.]*?)(?:perform|do|create|provide)/i;
if (aiRefusalError.test(attempt)) {
throw new Error('AI Refusal');
}
const isAbstractWrap = attempt.includes('&&&') && attempt.includes('@@@');
const isBacktickWrap = attempt.includes('```');
if (isAbstractWrap || isBacktickWrap) {
let innerBlockText = '';
let supportingText = '';
if (isBacktickWrap) {
const processedText = processTextWithCodeBlock(attempt);
innerBlockText = processedText.codeBlock;
supportingText = processedText.supportingText;
} else {
const outerBlockStart = attempt.indexOf('&&&') + 3;
const outerBlockEnd = attempt.lastIndexOf('&&&');
const pretextEnd = attempt.indexOf('@@@');
const innerBlockStart = pretextEnd + 3;
const innerBlockEnd = attempt.lastIndexOf('@@@');
const postTextStart = innerBlockEnd + 3;
innerBlockText = attempt.slice(innerBlockStart, innerBlockEnd);
const pretext = attempt.slice(outerBlockStart, pretextEnd);
const posttext = attempt.slice(postTextStart, outerBlockEnd);
supportingText = pretext + '\n' + posttext;
console.log({
ABSTRACTMATCHFOUND: true,
outerBlockStart,
outerBlockEnd,
pretextEnd,
innerBlockStart,
innerBlockEnd,
postTextStart
});
}
console.log({ supportingText, innerBlockText })
if (!innerBlockText.length) {
throw new Error('cannot parse Block structure is not valid.');
}
try {
if (innerBlockText.startsWith('{') || innerBlockText.startsWith('[')) {
JSON.parse(innerBlockText);
}
} catch (error) {
const err = error as Error;
throw new Error('cannot parse json.' + err.message)
}
console.log("Validating innerblocktext : ", innerBlockText)
const result = validateTypedResponse<T>(innerBlockText);
return { message: result, supportingText };
}
attempt = stripWrappedCharacter(attempt);
console.log("Parsing a basic attempt: ", attempt);
const result = validateTypedResponse<T>(attempt);
return { message: result, supportingText: '' };
}
export let responseValidators = [
isConvertPurposeResult,
isFileEditorResult,
isGuidedEditResult,
isCreateTypeResponse,
isCreateApiResult,
isCreateApiBackendResult,
isGeneralComponentResponse
];
| export function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void { |
responseValidators = responseValidators.concat(validators);
}
export function validateTypedResponse<T>(response: string): T {
if (!response) {
throw new Error('empty response');
}
try {
let body: GuardValidations = response;
try {
body = JSON.parse(response);
} catch (error) {}
for (const tg of responseValidators) {
if (body && tg(body)) {
return body as T;
}
console.log('Guard function:', tg.name, 'Result:', tg(body));
}
} catch (error) { }
throw new Error('bad chat format');
} | src/server/parser.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/prompts/file_editor_prompt.ts",
"retrieved_chunk": "export type FileEditorResponse = `${number}. ${string}`;\nexport function isFileEditorResult(obj: GuardValidations): boolean {\n return 'string' === typeof obj && fileEditorResponseRegex.test(obj);\n}",
"score": 21.55538696295318
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "];\nexport type CreateTypeTypeName = `I${string}`;\nexport type CreateTypeResponse = `type ${CreateTypeTypeName} =`;\nexport function isCreateTypeResponse(obj: GuardValidations): boolean {\n let createTypeResponseRegex = new RegExp(/type\\s+I\\w+\\s*=\\s*\\{/gm);\n return 'string' === typeof obj && createTypeResponseRegex.test(obj);\n}",
"score": 21.08403882286084
},
{
"filename": "src/lib/prompts/create_gen_component_prompt.ts",
"retrieved_chunk": " { role: 'user', content: '${prompt1}' }\n];\nconst generalComponentResponseRegex = /export default/ig;\ntype GeneralComponentKey = string;\nexport type GeneralComponentResponse = `export default function ${GeneralComponentKey}() {`;\nexport function isGeneralComponentResponse(obj: GuardValidations): boolean {\n return 'string' === typeof obj && generalComponentResponseRegex.test(obj);\n}",
"score": 19.111069073325076
},
{
"filename": "src/lib/prompts/create_api_prompt.ts",
"retrieved_chunk": "export type CreateApiResult = `const ${CreateApiKey}Api =`;\nexport function isCreateApiResult(obj: GuardValidations): obj is CreateApiResult {\n return 'string' === typeof obj && createApiFormat.test(obj);\n}",
"score": 17.905116537523774
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;\nexport type GuidedEditResponse = Record<GuidedEditKeys, string>[];\nexport function isGuidedEditResult(obj: GuardValidations): boolean {\n return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {\n const guidedEditKey = new RegExp(`^${test}_\\\\d+$`);\n return hasSimilarKey(item, guidedEditKey)\n }));\n}",
"score": 17.01528654191767
}
] | typescript | export function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void { |
#!/usr/bin/env node
import yargs from 'yargs/yargs';
import { config, saveConfig, getConfigValue, checkConfigExists } from './config';
import * as spells from './spells';
import { IPrompts } from '../lib/prompts';
const parser = yargs(process.argv.slice(2))
// .options({
// 'config': {
// alias: 'c',
// describe: 'Path to the configuration file',
// default: 'config.json',
// type: 'string',
// },
// 'verbose': {
// alias: 'v',
// describe: 'Display verbose output',
// default: false,
// type: 'boolean',
// },
// })
.command(
'set [key] [value]',
'Set a configuration value',
(yargs) => {
return yargs.positional('key', {
describe: 'Configuration key to set',
type: 'string',
}).positional('value', {
describe: 'Value to set for the configuration key',
type: 'string',
});
},
(argv) => {
checkConfigExists();
if (!argv.key) throw new Error('key required');
const keys = argv.key.split('.');
const [current, lastKey] = | getConfigValue(config, keys); |
current[lastKey] = argv.value || '';
saveConfig();
}
)
.command(
'use-ai [promptType] [prompts...]',
'Use AI with the specified prompts',
(yargs) => {
return yargs
.positional('promptType', {
describe: 'The type of prompt to use',
default: undefined,
type: 'string',
})
.positional('prompts', {
describe: 'Prompts',
demandOption: true,
type: 'string',
nargs: 1,
array: true,
});
},
async (argv) => {
await spells.useAi(argv.promptType as IPrompts | undefined, ...argv.prompts)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'guided-edit [fileNameWithInstructions] [optionalName]',
'Run guided edit',
(yargs) => {
return yargs
.positional('fileNameWithInstructions', {
describe: 'File name with instructions',
type: 'string',
demandOption: true
})
.positional('optionalName', {
describe: 'Optional name',
type: 'string',
})
.options({
'commit': {
type: 'boolean',
description: 'Will commit edits to the generated branch',
default: true,
},
'pull-request': {
type: 'boolean',
description: 'Will create and add to 1 pull request per generated branch',
default: true,
},
});
},
async (argv) => {
await spells.guidedEdit(argv.fileNameWithInstructions, argv.optionalName)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'file-editor <fileName> [instructions...]',
'Edit any file',
(yargs) => {
return yargs
.positional('fileName', {
describe: 'File Name',
type: 'string',
demandOption: true
})
.positional('instructions', {
describe: 'File name with instructions',
type: 'string',
array: true,
demandOption: true
});
},
async (argv) => {
await spells.fileEditor(argv.fileName, ...argv.instructions)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-component [description]',
'Create a component',
(yargs) => {
return yargs
.positional('description', {
describe: 'Component description',
demandOption: true,
type: 'string',
});
},
async (argv) => {
await spells.createComponent(argv.description)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-api [typeName]',
'Create an API',
(yargs) => {
return yargs
.positional('typeName', {
describe: 'API type name',
demandOption: true,
type: 'string',
});
},
async (argv) => {
const generatedType = await spells.createType(argv.typeName)
await spells.createApi(argv.typeName, generatedType)
.then((result) => console.log(result))
.catch((error) => console.error(error));
await spells.createApiBackend(argv.typeName, generatedType);
}
)
.demandCommand(1, 'You need at least one command before moving on')
.help()
.alias('h', 'help')
.strict();
(async () => {
await parser.argv;
})(); | src/server/cli.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Helper function\nexport function getConfigValue(config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] {\n let current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config;\n for (let i = 0; i < keys.length - 1; i++) {\n if (!isConfigNestedObject(current[keys[i]])) {\n throw new Error('invalid config key');\n }\n current = current[keys[i]] as Record<string, ConfigPropTypes>;\n }\n return [current, keys[keys.length - 1]];",
"score": 45.38611363123588
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// }\n// export function walkNode(rootNode: SyntaxNode) {\n// const linearText: Record<number, string> = {};\n// const nodes: SyntaxNode[] = [];\n// function innerWalk (node: SyntaxNode) {\n// for (const child of node.children) {\n// const key = child.startPosition.row;\n// if (!linearText[key]) {\n// linearText[key] = \"\";\n// }",
"score": 28.301287794385104
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n if (Array.isArray(obj)) {\n return obj.map((item) => deepClone(item) as T) as unknown as T;\n }\n const result: Record<string, unknown> = {};\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = deepClone((obj as Record<string, unknown>)[key]);",
"score": 27.019183968406644
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " const edit = key && editedLines[key as keyof typeof editedLines];\n if (edit) {\n return edit.replace(regex, ''); \n }\n return l.slice(match?match[0].length:0);\n }).filter(l => l?.length > 0).join('\\n');\n console.log({ lined, editedLines, editedFile, editNum: Object.keys(editedLines).length });\n const saved = saveTargetFile(fileName, editedFile);\n return saved;\n}",
"score": 26.16400470058798
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// linearText[key] += (linearText[key] ? \" \" : \"\") + child.text;\n// // Recursion for deeper levels\n// if (child.children && child.children.length > 0 && !linearText[key].includes(child.children[0].text)) {\n// innerWalk(child);\n// }\n// }\n// }\n// innerWalk(rootNode)\n// return nodes;\n// }",
"score": 23.51114200203039
}
] | typescript | getConfigValue(config, keys); |
import fs from 'fs';
import path from "path";
import { sync } from 'fast-glob';
import { isCalledWithNpx, isCliRunning } from "./config";
import languages from "../lib/languages";
import type { OpenAIRequestShapes } from './types';
import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from 'openai';
const langValues = Object.values(languages);
export const codeGPTPrecursor = 'You are BacktickGPT, providing only typescript code responses wrapped with 3 backticks before and after.';
export function deepClone<T>(obj: T): T {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map((item) => deepClone(item) as T) as unknown as T;
}
const result: Record<string, unknown> = {};
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = deepClone((obj as Record<string, unknown>)[key]);
}
}
return result as T;
}
export const isValidName = (name: string): boolean => {
const regex = /^I[A-Z][a-zA-Z]*$/;
return regex.test(name);
};
export const toSnakeCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);
};
export const toTitleCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
};
export function extractCodeBlock(inputString: string, delimeter: string = '```', languages: string[] = ['typescript', 'json', 'jsx', 'tsx']) {
const langStartTag = (language: string) => language ? `${delimeter}${language}` : delimeter;
for (const language of languages) {
const startTag = langStartTag(language);
if (inputString.includes(startTag)) {
return {
codeBlock: inputString.split(startTag)[1].split(delimeter)[0],
index: inputString.indexOf(startTag) + startTag.length,
};
}
}
if (inputString.includes(delimeter)) {
const index = inputString.indexOf(delimeter) + delimeter.length;
return {
codeBlock: inputString.split(delimeter)[1],
index,
};
}
return {
codeBlock: inputString,
index: 0,
};
};
export function extractCodeBlockPre(inputString: string, index: number): string {
return inputString.substring(0, index)?.trim() || '';
}
export function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {
return inputString.substring(index).split(delimeter)[1]?.trim() || '';
}
export function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {
const { codeBlock, index } = extractCodeBlock(inputString);
const preText = extractCodeBlockPre(inputString, index);
const postText = extractCodeBlockPost(inputString, index);
return {
codeBlock,
supportingText: preText + ' ' + postText,
};
}
export function stripWrappedCharacter(inputString: string, wrappedCharacters: string[] = ['"', "'"]): string {
for (const char of wrappedCharacters) {
if (inputString.startsWith(char)) inputString = inputString.slice(1);
if (inputString.endsWith(char)) inputString = inputString.substring(0, inputString.length - 1);
}
return inputString;
}
export function sanitizeName(input: string): string {
// Trim whitespaces and replace consecutive spaces with a single dash
const trimmed = input.trim();
// Remove invalid characters: ~ ^ : ? * [ ] @ { } \ /
const sanitized = trimmed.replace(/[~^:?"*\[\]@{}\\/]+/g, '');
// Limit branch name length to 100 characters
const maxLength = 100;
const shortened = sanitized.slice(0, maxLength);
// Remove leading and trailing period (.)
const noLeadingTrailingPeriods = shortened.replace(/(^\.+|\.+$)/g, '');
// Remove leading and trailing forward slash (-)
const result = noLeadingTrailingPeriods.replace(/(^-+|-+$)/g, '');
return result;
}
export function ensureKeysAreQuoted(jsonString: string): string {
const unquotedKeysRegex = /([{,]\s*)(\w+)\s*:/g;
function quoteKeys(match: unknown, prefix: string, key: string) {
return `${prefix}"${key}":`;
}
return jsonString.replace(unquotedKeysRegex, quoteKeys);
}
export function typeDefinitionToSentence(typeDefinition: string): string {
const typeNameMatch = typeDefinition.match(/export type (\w+)/);
if (!typeNameMatch) {
return 'Invalid type definition provided.';
}
const typeName = typeNameMatch[1];
const properties = [];
const propertyRegex = /(\w+)\s*:\s*([^;]+);/g;
let match;
while ((match = propertyRegex.exec(typeDefinition)) !== null) {
properties.push({ key: match[1], type: match[2].trim().replace(/\s+/g, ' ') });
}
if (properties.length > 0) {
const propertiesDescription = properties
.map((property) => `${property.key} as a ${property.type}`)
.join(', ');
return `${typeName} defines ${propertiesDescription}.`;
} else {
const recordMatch = typeDefinition.match(/Record<(.+),\s*(.+)>/);
if (recordMatch) {
return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;
}
}
return 'Unable to parse the type definition.';
}
export function getDirPathOf(filePath: string) {
return path.dirname(filePath)
}
export function generateTempFilePath(dir: string, name: string) {
return path.join(dir, `${name}-${Date.now()}.json`)
}
export function getRootDir() {
return isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../');
}
export function getPathOf(name: string, baseDir?: string): string {
return path.join(baseDir || getRootDir(), name);
}
export function getFileParser(fileName: string) {
const extension = path.extname(fileName);
const parser = langValues.find(l => l.fileExtension.includes(extension));
if (!parser) throw 'That parser is undefined!';
return parser.parserName;
}
export function getFileFromDir(file: string, dir: string = __dirname) {
const files = fs.readdirSync(dir);
const fileName = files.find(f => f.startsWith(file));
if (!fileName) throw 'File not found.';
return fs.readFileSync(path.join(dir, fileName), { encoding: 'utf-8' })
}
export function getTargetFile(targetFile: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string | null {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return files.length > 0 ? fileContent : null;
}
export function saveTargetFile(targetFile: string, contents: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.writeFileSync(files[0], contents, { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return 'file saved';
}
const excludeDirectories = [
'node_modules',
'vendor',
'dist',
'build',
'.git',
'.svn',
// add other directories to exclude
];
| export function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest { |
return 'messages' in obj;
}
export function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {
return 'prompt' in obj;
}
export function isModerationRequest(obj: OpenAIRequestShapes): obj is CreateModerationRequest {
return 'input' in obj;
} | src/server/util.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "export function isChatResponse<T>(obj: GuardValidations): obj is ChatResponse<T> {\n return 'object' === typeof obj && 'message' in obj && Array.isArray(obj.message);\n}\nexport function isCompletionResponse(obj: GuardValidations): obj is CompletionResponse {\n return 'object' === typeof obj && 'message' in obj && 'string' === typeof obj.message;\n}\nexport function isModerationResponse(obj: GuardValidations): obj is ModerationResponse {\n return 'object' === typeof obj && 'input' in obj;\n}",
"score": 17.951124978430062
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 17.1660326337909
},
{
"filename": "src/lib/prompts/create_api_prompt.ts",
"retrieved_chunk": "export type CreateApiResult = `const ${CreateApiKey}Api =`;\nexport function isCreateApiResult(obj: GuardValidations): obj is CreateApiResult {\n return 'string' === typeof obj && createApiFormat.test(obj);\n}",
"score": 16.302299504442708
},
{
"filename": "src/server/types.ts",
"retrieved_chunk": "import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from \"openai\";\nexport type OpenAIRequestShapes = CreateChatCompletionRequest | CreateCompletionRequest | CreateModerationRequest;",
"score": 15.938970814112523
},
{
"filename": "src/lib/prompts/create_api_backend_prompt.ts",
"retrieved_chunk": " 6. Response Technique is the following verbatim text with variables replaced by <>: &&&@@@<RESPONSE_BODY>@@@&&&\n 7. Validate Response: The response returned to the user follows the exact format of Step 6: eg. &&&@@@const customizedApiHandlers: ApiHandler<typeof customizedApi> = {\\n transferred functionality customized around FILE_RELATED_TYPE\\n }@@@&&&` },\n { role: 'user', content: 'FILE_RELATED_TYPE=\\${prompt1}' }\n];\nconst createApiFormat = /^const\\s+\\w+ApiHandlers:\\s+ApiHandler/gim;\ntype CreateApiBackendKey = string;\nexport type CreateApiBackendResult = `const ${CreateApiBackendKey}ApiHandlers: ApiHandler`;\nexport function isCreateApiBackendResult(obj: GuardValidations): obj is CreateApiBackendResult {\n return 'string' === typeof obj && createApiFormat.test(obj);\n}",
"score": 13.417318376271563
}
] | typescript | export function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest { |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await | prepareBranch(editingUser || config.user.name); |
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {});
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " console.log({ fileParts });\n const config = getConfig();\n if (!config.ts.compDir) {\n throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const [fileName, ...suggestedEdits] = fileParts;\n const originalFileContents = getTargetFile(fileName, config.git.rootPath);",
"score": 76.1627842751794
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 70.72987535095993
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n if (!config.ts.typeDir) {\n throw new Error('Missing ts.typeDir.');\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const coreTypesPath = sanitizeName(config.ts.typeDir);\n const typeFileName = getPathOf(`${coreTypesPath}/${toSnakeCase(typeName)}.ts`);\n const sourceFile = project.addSourceFileAtPath(typeFileName);",
"score": 63.59992097145822
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": "import { Project } from 'ts-morph';\nimport { getConfig } from '../config';\nimport { getPathOf, sanitizeName, toSnakeCase, toTitleCase } from '../util';\nimport { useAi } from './use_ai_spell';\nimport { IPrompts } from '../../lib/prompts';\nimport { CreateApiBackendResult } from '../../lib/prompts/create_api_backend_prompt';\nexport async function createApiBackend(typeName: string, generatedType: string): Promise<string> {\n const config = getConfig();\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.');",
"score": 46.4960699379333
},
{
"filename": "src/lib/prompts/file_editor_prompt.ts",
"retrieved_chunk": "4. Lorem ipsum dolor sit amet. :) /* change: added text */\n\\`\\`\\`\nPlease find the 1 change above this line.`},\n { role: 'user', content: `remove_and_edit_text_example.js\ninstructions: remove any console logs. change ts.configPath to ts.configRoot\n1. const config = getConfig();\n2. if (!config.ts.compDir) {\n3. console.log('hey');\n4. throw new Error('Missing ts.compDir.')\n5. }",
"score": 41.30334499710268
}
] | typescript | prepareBranch(editingUser || config.user.name); |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory = deepClone(completionStringOrMessageHistory);
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if | (isChatRequest(request)) { |
const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
} else if (isCompletionRequest(request)) {
const completionResponse = await openai.createCompletion(request, openAIRequestOptions);
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
} else if (isModerationRequest(request)) {
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " 'commit': {\n type: 'boolean',\n description: 'Will commit edits to the generated branch',\n default: true,\n },\n 'pull-request': {\n type: 'boolean',\n description: 'Will create and add to 1 pull request per generated branch',\n default: true,\n },",
"score": 23.993373879047105
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": "import { parseChatAttempt } from '../parser';\nimport { IPrompts } from '../../lib/prompts';\nimport { buildOpenAIRequest, performRequest } from '../request';\nimport { logAiResult } from '../stats';\nimport { getConfig } from '../config';\nimport type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';\nimport { isCompletionRequest } from '../util';\nexport async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {\n const config = getConfig();\n const retries = parseInt(config.ai.retries, 10);",
"score": 23.13610156168918
},
{
"filename": "src/server/index.ts",
"retrieved_chunk": "export * from './spells';\nexport * from './parser';\nexport * from './util';\nexport * from './request';\nexport * from './stats';\nexport type {\n OpenAIRequestShapes\n} from './types';",
"score": 22.925925306935028
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " 'dist',\n 'build',\n '.git',\n '.svn',\n // add other directories to exclude\n];\nexport function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest {\n return 'messages' in obj;\n}\nexport function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {",
"score": 21.173231011827195
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const responseTry = await performRequest(builtRequest);\n aiResponse.rawResponses.push(responseTry);\n if ('undefined' === typeof responseTry) {\n const noChoices = 'Open AI returned no choices.'\n aiResponse.failures.push(noChoices);\n throw new Error(noChoices);\n }\n if ('boolean' === typeof responseTry) {\n const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };\n console.log('MODERATION RESPONSE :==: ', moderationResponse)",
"score": 20.667229860675
}
] | typescript | (isChatRequest(request)) { |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory = deepClone(completionStringOrMessageHistory);
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if (isChatRequest(request)) {
const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
} else if (isCompletionRequest(request)) {
| const completionResponse = await openai.createCompletion(request, openAIRequestOptions); |
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
} else if (isModerationRequest(request)) {
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 49.775803460048
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " 'commit': {\n type: 'boolean',\n description: 'Will commit edits to the generated branch',\n default: true,\n },\n 'pull-request': {\n type: 'boolean',\n description: 'Will create and add to 1 pull request per generated branch',\n default: true,\n },",
"score": 44.117562167894526
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const responseTry = await performRequest(builtRequest);\n aiResponse.rawResponses.push(responseTry);\n if ('undefined' === typeof responseTry) {\n const noChoices = 'Open AI returned no choices.'\n aiResponse.failures.push(noChoices);\n throw new Error(noChoices);\n }\n if ('boolean' === typeof responseTry) {\n const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };\n console.log('MODERATION RESPONSE :==: ', moderationResponse)",
"score": 40.452563623550176
},
{
"filename": "src/server/index.ts",
"retrieved_chunk": "export * from './spells';\nexport * from './parser';\nexport * from './util';\nexport * from './request';\nexport * from './stats';\nexport type {\n OpenAIRequestShapes\n} from './types';",
"score": 39.795454314280285
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": "import { parseChatAttempt } from '../parser';\nimport { IPrompts } from '../../lib/prompts';\nimport { buildOpenAIRequest, performRequest } from '../request';\nimport { logAiResult } from '../stats';\nimport { getConfig } from '../config';\nimport type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';\nimport { isCompletionRequest } from '../util';\nexport async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {\n const config = getConfig();\n const retries = parseInt(config.ai.retries, 10);",
"score": 37.62825774633488
}
] | typescript | const completionResponse = await openai.createCompletion(request, openAIRequestOptions); |
import { ChatCompletionRequestMessage } from "openai";
import type { GuardValidations } from "../types";
import { hasSimilarKey } from "./prompt_utils";
// const guidedEditPrompt = [
// { role: 'system', content: 'As CodeWhittler I transform STATEMENTS_JSON, deriving RESPONSE_ARRAY from TARGET_STATE modifications.' },
// { role: 'assistant', content: `Whittling Supplies Required:
// - STATEMENTS_JSON: a JSON object with string keys and string Typescript code statement values
// - TARGET_STATE: the desired state of the Typescript code statements
// Carving Process:
// I'll examine STATEMENTS_JSON object, consider TARGET_STATE, and return a carefully whittled RESPONSE_ARRAY array. This whittling process ensures that your application runs swiftly and efficiently.
// Whittling Technique:
// 1. Identify: TARGET_STATE_RELEVANCE is assigned to each STATEMENTS_JSON value.
// - Relevance is an internal measurement determining the liklihood that modifying the STATEMENTS_JSON value will contribute to TARGET_STATE.
// 2. Filter: ACTION_ITEMS filters STATEMENTS_JSON based on TARGET_STATE_RELEVANCE.
// - Any Relevance: Include
// - No Relevance: Exclude
// 3. Execute: Perform various tasks on ACTION_ITEMS to reach TARGET_STATE.
// - Update: Any ACTION_ITEMS may be updated.
// - Insert: New ACTION_ITEMS may be added with "above_#" or "below_#" as a key using an adjacent statement #. Inserted functionality (above_#/below_#) is positioned relative to an adjacent statement (eg. above_5 is a new statement above statement_5), or the beginning/end of file (eg. above_0 is a new statement at the start of the file).
// - Remove: Any ACTION_ITEMS value may be set to an empty string.
// 4. Validate: ACTION_ITEMS are valid Typescript.
// 5. Build: RESPONSE_ARRAY is a JSON array of objects { "ACTION_ITEM_KEY": "ACTION_ITEMS[ACTION_ITEM_KEY]" }.
// 6. Build Validation: RESPONSE_ARRAY is a properly formatted and escaped JSON array.
// Response Template:
// All responses given by me follow this exact format enclosed in 3 ampersands.
// &&&
// <2 very short comments describing the overall changes>
// The modified subset of keys: ...ACTION_ITEM_KEYS
// @@@
// [ ...RESPONSE_ARRAY ] // in string format for example: '[ { "above_5": "inserted code statement", "statement_9": "existing modified code statement", "below_13": "inserted code statement" }, ]'
// @@@
// &&&
// Following Steps:
// Provide the necessary context in the statements for me to carry out the modifications. Use the keywords STATEMENTS_JSON and TARGET_STATE to convey the required inputs:
// TARGET_STATE --- <an english phrase with some coding terms>
// STATEMENTS_JSON --- <a plain old javascript object (POJO)>
// On receiving TARGET_STATE and STATEMENTS_JSON, I'll start whittling away on the STATEMENTS_JSON as needed, to achieve TARGET_STATE, in order to derive RESPONSE_ARRAY.`},
// { role: 'user', content: ' TARGET_STATE --- ${prompt1}\n STATEMENTS_JSON --- ${prompt2}' }
// ];
// const testSystem = 'you are a helpful typescript coding assistant';
// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown "```typescript" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'
export const guidedEditMessages: ChatCompletionRequestMessage[] = [
{ role: 'system', content: 'I change code from a JSON object to an array based on the target state.' },
{ role: 'assistant', content: `What I need:
JSON object with code statements
Desired state of the code statements
What I do:
Check which statements in the JSON object can help reach the desired state.
Keep only useful statements.
Change the statements to reach the target state. I can update, insert, or remove statements.
Make sure the updated code is valid Typescript.
Create an array with the updated code.
Ensure the array is properly formatted.
Response format:
I'll provide the changes made in a specific format like this:
&&&
<2 short comments on changes>
Modified keys: ...KEYS
@@@
[ ...ARRAY ] // example: '[ { "above_5": "new code", "statement_9": "changed code", "below_13": "new code" }, ]'
@@@
&&&
Next steps:
Give me the desired state and JSON object with code statements using these keywords:
TARGET_STATE --- <phrase with code terms>
STATEMENTS_JSON --- <a simple JSON object>
I'll change the code in the JSON object to reach the target state and create the final array.`},
{ role: 'user', content: ' TARGET_STATE --- ${prompt1}\n STATEMENTS_JSON --- ${prompt2}' }
];
export type GuidedEditKeyPrefix = 'statement' | 'above' | 'below';
export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;
export type GuidedEditResponse = Record<GuidedEditKeys, string>[];
| export function isGuidedEditResult(obj: GuardValidations): boolean { |
return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {
const guidedEditKey = new RegExp(`^${test}_\\d+$`);
return hasSimilarKey(item, guidedEditKey)
}));
} | src/lib/prompts/guided_edit_prompt.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/prompts/convert_purpose_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\nexport const convertPurposeMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'You respond with a single gerund phrase, 5 to 8 words, which will complete the user\\'s sentence. For example, \"walking in the sunshine with you\".' },\n { role: 'assistant', content: 'Give me an incomplete sentence that I can complete with a gerund phrase. For example, if you said \"Our favorite past time is\", I might respond \"walking in the sunshine with you\"' },\n { role: 'user', content: 'An organization named \"${prompt1}\" is interested in \"${prompt2}\" and their mission statement is' }\n];\nexport type ConvertPurposeResult = string;\nconst convertPurposeRegex = /\\b[a-z]*ing\\b/i;\nexport function isConvertPurposeResult(obj: GuardValidations): obj is ConvertPurposeResult {",
"score": 62.8268134335754
},
{
"filename": "src/lib/prompts/file_editor_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\n// const fileEditorPrompt = [\n// { role: 'system', content: 'you are a helpful file editing assistant' },\n// { role: 'user', content: 'edit ${prompt1} with regard to ${prompt2}. only show edited lines. remember to encase the edited code inside proper markdown \"```\" header. \\n\\n ${prompt1}:\\n${prompt3}' }\n// ];\nexport const fileEditorMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'You, CodeCommenter, follow user instructions to add, edit, and delete text in specific ways, leaving change comments. You only reply with the line number + the change comment + the new content of the line. 3 possible static comments: \"/* change: added text */\", \"/* change: edited text */\", and \"/* change: fully removed text */\". Your reply includes only changed lines which have change comments, and clearly formats it in an anonymous markdown backtick block.' },\n // { role: 'system', content: 'You reply with: \"I only edited line {number of each edited line}, so I am just going to show you {number of edited lines} lines, including empty lines:\"' },\n { role: 'user', content: `add_text_example.txt",
"score": 57.681033125795125
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\n// const createTypePrompt = 'Complete the following typescript type with 4-7 unconventionally named properties, using string, number or boolean, starting with its opening bracket, \"type ${prompt1} =';\n// const createTypeMessages = [\n// { role: 'system', content: 'I, TypescriptTypeGeneratorGPT, respond with a code statement declaring a Typescript type, based on the name of a type.' },\n// { role: 'assistant', content: `This message describes how \\${prompt1} will be generated and returned in the next message.\n// 1. Parse Name: You provided a name in the format of ITypeName, \\${prompt1}, which I will evaluate to determine its general informational context.\n// 2. Primary Action: Generate TYPE_DEFINITION of 4-7 unconventionally named properties.\n// 3. Primary Validation: TYPE_DEFINITION is validated as starting with text \"type \\${prompt1} = {\" with the rest of TYPE_DEFINITION to follow.\n// 4. Secondary Validation: Exact response text verified to be formatted in the following pattern:",
"score": 55.20856224005416
},
{
"filename": "src/lib/prompts/file_editor_prompt.ts",
"retrieved_chunk": "9. throw new Error('Missing ts.configRoot.') /* change: edited text */\n\\`\\`\\`\nPlease find the 4 changes above this line.` },\n { role: 'user', content: `\\${prompt1}\n\\${prompt2}\n\\${prompt3}`}\n];\n// const testSystem = 'you are a helpful typescript coding assistant';\n// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown \"```typescript\" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'\nconst fileEditorResponseRegex = /^\\d+./igm;",
"score": 47.044822583853176
},
{
"filename": "src/lib/prompts/suggest_role_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport { generateExample, getSuggestionPrompt } from \"./prompt_utils\";\nexport const suggestRoleMessagesOld = `${getSuggestionPrompt('role names for a group named ${prompt1} which is interested in ${prompt2}')}\n${generateExample('role names for a group named writing center which is interested in consulting on writing', 'Tutor|Student|Advisor|Administrator|Consultant')}\n${generateExample('role names for a group named city maintenance department which is interested in maintaining the facilities in the city', 'Dispatcher|Engineer|Administrator|Technician|Manager')}`;\nexport const suggestRoleMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'I, DelimitedOptions, will provide 5 options delimited by |.' },\n { role: 'assistant', content: `Simply provide your desired prompt, and I\\'ll fill in the result!\n Here are some examples: ${suggestRoleMessagesOld}\n Provide the following text \"Prompt: <some prompt> Result:\" and I will complete the result.` },",
"score": 41.96161044840642
}
] | typescript | export function isGuidedEditResult(obj: GuardValidations): boolean { |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {});
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await | pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`); |
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n }\n try {\n const generatedApiBackend = await useAi<CreateApiBackendResult>(IPrompts.CREATE_API_BACKEND, generatedType + ' ' + apiEndpoints.join(' '))\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`;\n sourceFile.insertText(sourceFile.getEnd(), `${comment}${generatedApiBackend.message}\\n\\n`);\n sourceFile.fixMissingImports();\n await project.save();\n } catch (error) {\n console.error(error);",
"score": 54.01604182076139
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 27.521845247374813
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n if (!config.ts.typeDir) {\n throw new Error('Missing ts.typeDir.');\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const coreTypesPath = sanitizeName(config.ts.typeDir);\n const typeFileName = getPathOf(`${coreTypesPath}/${toSnakeCase(typeName)}.ts`);\n const sourceFile = project.addSourceFileAtPath(typeFileName);",
"score": 25.269926152424645
},
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " await git.checkoutBranch(generatedBranch, config.git.source);\n await git.push(config.git.remote, generatedBranch, ['--set-upstream', generatedBranch])\n } catch (error) {\n const err = error as Error;\n if (err.message.includes('A branch named') && err.message.includes('already exists')) {\n console.log('Checking out existing generated branch ', generatedBranch);\n await git.checkout(generatedBranch);\n console.log('Pulling generated branch.');\n await git.pull(config.git.remote, generatedBranch);\n }",
"score": 23.421613054913546
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " let componentName;\n const exportedDeclarations = sourceFile.getExportedDeclarations().get('default');\n if (exportedDeclarations) {\n const declaration = exportedDeclarations[0];\n if (Node.isVariableDeclaration(declaration)) {\n const initializer = declaration.getInitializer();\n if (initializer?.getKind() === SyntaxKind.FunctionExpression || initializer?.getKind() === SyntaxKind.ArrowFunction) {\n componentName = declaration.getName();\n }\n } else if (Node.isFunctionDeclaration(declaration)) {",
"score": 18.249395401305627
}
] | typescript | pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`); |
import { isConvertPurposeResult } from "../lib/prompts/convert_purpose_prompt";
import { isCreateApiBackendResult } from "../lib/prompts/create_api_backend_prompt";
import { isCreateApiResult } from "../lib/prompts/create_api_prompt";
import { isGeneralComponentResponse } from "../lib/prompts/create_gen_component_prompt";
import { isCreateTypeResponse } from "../lib/prompts/create_type_prompt";
import { isFileEditorResult } from "../lib/prompts/file_editor_prompt";
import { isGuidedEditResult } from "../lib/prompts/guided_edit_prompt";
import type { GuardValidations } from "../lib/types";
import { processTextWithCodeBlock, stripWrappedCharacter } from "./util";
export function parseChatAttempt<T>(attempt: string): { supportingText: string, message: T } {
const aiRefusalError = /(^i\'m sorry)|(?:ai(?:\s|-)?language(?:\s|-)?model|i(?:'?m| am))(?:[^.]*?)(?:can(?:'?t| not)|unable to)(?:[^.]*?)(?:perform|do|create|provide)/i;
if (aiRefusalError.test(attempt)) {
throw new Error('AI Refusal');
}
const isAbstractWrap = attempt.includes('&&&') && attempt.includes('@@@');
const isBacktickWrap = attempt.includes('```');
if (isAbstractWrap || isBacktickWrap) {
let innerBlockText = '';
let supportingText = '';
if (isBacktickWrap) {
const processedText = processTextWithCodeBlock(attempt);
innerBlockText = processedText.codeBlock;
supportingText = processedText.supportingText;
} else {
const outerBlockStart = attempt.indexOf('&&&') + 3;
const outerBlockEnd = attempt.lastIndexOf('&&&');
const pretextEnd = attempt.indexOf('@@@');
const innerBlockStart = pretextEnd + 3;
const innerBlockEnd = attempt.lastIndexOf('@@@');
const postTextStart = innerBlockEnd + 3;
innerBlockText = attempt.slice(innerBlockStart, innerBlockEnd);
const pretext = attempt.slice(outerBlockStart, pretextEnd);
const posttext = attempt.slice(postTextStart, outerBlockEnd);
supportingText = pretext + '\n' + posttext;
console.log({
ABSTRACTMATCHFOUND: true,
outerBlockStart,
outerBlockEnd,
pretextEnd,
innerBlockStart,
innerBlockEnd,
postTextStart
});
}
console.log({ supportingText, innerBlockText })
if (!innerBlockText.length) {
throw new Error('cannot parse Block structure is not valid.');
}
try {
if (innerBlockText.startsWith('{') || innerBlockText.startsWith('[')) {
JSON.parse(innerBlockText);
}
} catch (error) {
const err = error as Error;
throw new Error('cannot parse json.' + err.message)
}
console.log("Validating innerblocktext : ", innerBlockText)
const result = validateTypedResponse<T>(innerBlockText);
return { message: result, supportingText };
}
| attempt = stripWrappedCharacter(attempt); |
console.log("Parsing a basic attempt: ", attempt);
const result = validateTypedResponse<T>(attempt);
return { message: result, supportingText: '' };
}
export let responseValidators = [
isConvertPurposeResult,
isFileEditorResult,
isGuidedEditResult,
isCreateTypeResponse,
isCreateApiResult,
isCreateApiBackendResult,
isGeneralComponentResponse
];
export function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void {
responseValidators = responseValidators.concat(validators);
}
export function validateTypedResponse<T>(response: string): T {
if (!response) {
throw new Error('empty response');
}
try {
let body: GuardValidations = response;
try {
body = JSON.parse(response);
} catch (error) {}
for (const tg of responseValidators) {
if (body && tg(body)) {
return body as T;
}
console.log('Guard function:', tg.name, 'Result:', tg(body));
}
} catch (error) { }
throw new Error('bad chat format');
} | src/server/parser.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 49.976303310503454
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " return await resolveAttempt(responseTry, retries) as UseAIResponses<T>;\n } catch (error) {\n const err = error as Error;\n aiResponse.successful = false;\n logAiResult({ ...aiResponse, prompts, message: err.message + ' ' + err.stack, model: builtRequest.model });\n throw new Error('General use AI failure!\\nStack: ' + err.stack);\n }\n}",
"score": 49.73691586691361
},
{
"filename": "src/server/git/check_git_cli.ts",
"retrieved_chunk": " } catch (error) {\n const err = error as Error;\n console.error(\"Error:\", err.message);\n return false;\n }\n}\nexport function gitCheck() {\n if (!checkGitCli()) throw new Error('github cli is required to be installed and configured in order to use this flow');\n}",
"score": 46.5276099068231
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " aiResponse.failures.push(imparsable);\n throw new Error(imparsable);\n }\n return await resolveAttempt(repeatedAttempt, retriesRemaining - 1);\n }\n const resolveIssue = 'Critical chat parse error or could not resolve a valid response after ' + retries + ' attempts. ' + (err.message ? 'Parsing error: ' + err.message : '');\n aiResponse.failures.push(resolveIssue);\n throw new Error(resolveIssue);\n }\n }",
"score": 45.081531055503056
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " responseMessage = 'guided edit produced no modifications for ' + fileName;\n }\n await goHome();\n return responseMessage;\n }\n } catch (error) {\n await goHome();\n const err = error as Error;\n return err.message + '\\n\\n' + err.stack;\n }",
"score": 41.402768351150726
}
] | typescript | attempt = stripWrappedCharacter(attempt); |
import { ChatCompletionRequestMessage } from "openai";
import type { GuardValidations } from "../types";
import { hasSimilarKey } from "./prompt_utils";
// const guidedEditPrompt = [
// { role: 'system', content: 'As CodeWhittler I transform STATEMENTS_JSON, deriving RESPONSE_ARRAY from TARGET_STATE modifications.' },
// { role: 'assistant', content: `Whittling Supplies Required:
// - STATEMENTS_JSON: a JSON object with string keys and string Typescript code statement values
// - TARGET_STATE: the desired state of the Typescript code statements
// Carving Process:
// I'll examine STATEMENTS_JSON object, consider TARGET_STATE, and return a carefully whittled RESPONSE_ARRAY array. This whittling process ensures that your application runs swiftly and efficiently.
// Whittling Technique:
// 1. Identify: TARGET_STATE_RELEVANCE is assigned to each STATEMENTS_JSON value.
// - Relevance is an internal measurement determining the liklihood that modifying the STATEMENTS_JSON value will contribute to TARGET_STATE.
// 2. Filter: ACTION_ITEMS filters STATEMENTS_JSON based on TARGET_STATE_RELEVANCE.
// - Any Relevance: Include
// - No Relevance: Exclude
// 3. Execute: Perform various tasks on ACTION_ITEMS to reach TARGET_STATE.
// - Update: Any ACTION_ITEMS may be updated.
// - Insert: New ACTION_ITEMS may be added with "above_#" or "below_#" as a key using an adjacent statement #. Inserted functionality (above_#/below_#) is positioned relative to an adjacent statement (eg. above_5 is a new statement above statement_5), or the beginning/end of file (eg. above_0 is a new statement at the start of the file).
// - Remove: Any ACTION_ITEMS value may be set to an empty string.
// 4. Validate: ACTION_ITEMS are valid Typescript.
// 5. Build: RESPONSE_ARRAY is a JSON array of objects { "ACTION_ITEM_KEY": "ACTION_ITEMS[ACTION_ITEM_KEY]" }.
// 6. Build Validation: RESPONSE_ARRAY is a properly formatted and escaped JSON array.
// Response Template:
// All responses given by me follow this exact format enclosed in 3 ampersands.
// &&&
// <2 very short comments describing the overall changes>
// The modified subset of keys: ...ACTION_ITEM_KEYS
// @@@
// [ ...RESPONSE_ARRAY ] // in string format for example: '[ { "above_5": "inserted code statement", "statement_9": "existing modified code statement", "below_13": "inserted code statement" }, ]'
// @@@
// &&&
// Following Steps:
// Provide the necessary context in the statements for me to carry out the modifications. Use the keywords STATEMENTS_JSON and TARGET_STATE to convey the required inputs:
// TARGET_STATE --- <an english phrase with some coding terms>
// STATEMENTS_JSON --- <a plain old javascript object (POJO)>
// On receiving TARGET_STATE and STATEMENTS_JSON, I'll start whittling away on the STATEMENTS_JSON as needed, to achieve TARGET_STATE, in order to derive RESPONSE_ARRAY.`},
// { role: 'user', content: ' TARGET_STATE --- ${prompt1}\n STATEMENTS_JSON --- ${prompt2}' }
// ];
// const testSystem = 'you are a helpful typescript coding assistant';
// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown "```typescript" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'
export const guidedEditMessages: ChatCompletionRequestMessage[] = [
{ role: 'system', content: 'I change code from a JSON object to an array based on the target state.' },
{ role: 'assistant', content: `What I need:
JSON object with code statements
Desired state of the code statements
What I do:
Check which statements in the JSON object can help reach the desired state.
Keep only useful statements.
Change the statements to reach the target state. I can update, insert, or remove statements.
Make sure the updated code is valid Typescript.
Create an array with the updated code.
Ensure the array is properly formatted.
Response format:
I'll provide the changes made in a specific format like this:
&&&
<2 short comments on changes>
Modified keys: ...KEYS
@@@
[ ...ARRAY ] // example: '[ { "above_5": "new code", "statement_9": "changed code", "below_13": "new code" }, ]'
@@@
&&&
Next steps:
Give me the desired state and JSON object with code statements using these keywords:
TARGET_STATE --- <phrase with code terms>
STATEMENTS_JSON --- <a simple JSON object>
I'll change the code in the JSON object to reach the target state and create the final array.`},
{ role: 'user', content: ' TARGET_STATE --- ${prompt1}\n STATEMENTS_JSON --- ${prompt2}' }
];
export type GuidedEditKeyPrefix = 'statement' | 'above' | 'below';
export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;
export type GuidedEditResponse = Record<GuidedEditKeys, string>[];
export function isGuidedEditResult(obj: GuardValidations): boolean {
return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {
const guidedEditKey = new RegExp(`^${test}_\\d+$`);
return | hasSimilarKey(item, guidedEditKey)
})); |
} | src/lib/prompts/guided_edit_prompt.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/prompts/file_editor_prompt.ts",
"retrieved_chunk": "export type FileEditorResponse = `${number}. ${string}`;\nexport function isFileEditorResult(obj: GuardValidations): boolean {\n return 'string' === typeof obj && fileEditorResponseRegex.test(obj);\n}",
"score": 44.86239216359208
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "];\nexport type CreateTypeTypeName = `I${string}`;\nexport type CreateTypeResponse = `type ${CreateTypeTypeName} =`;\nexport function isCreateTypeResponse(obj: GuardValidations): boolean {\n let createTypeResponseRegex = new RegExp(/type\\s+I\\w+\\s*=\\s*\\{/gm);\n return 'string' === typeof obj && createTypeResponseRegex.test(obj);\n}",
"score": 44.23506692031887
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n if (Array.isArray(obj)) {\n return obj.map((item) => deepClone(item) as T) as unknown as T;\n }\n const result: Record<string, unknown> = {};\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = deepClone((obj as Record<string, unknown>)[key]);",
"score": 43.2092964479998
},
{
"filename": "src/lib/prompts/prompt_utils.ts",
"retrieved_chunk": "export function getSuggestionPrompt(prompt: string) {\n return `Generate 5 ${prompt}; Result is 1-3 words separated by |. Here are some examples: `;\n}\nexport function generateExample(prompt: string, result: string = '') {\n return `Phrase: ${prompt}\\nResult: ${result}`;\n}\nexport function hasSimilarKey(obj: Record<string, unknown>, regex: RegExp): boolean {\n return Object.keys(obj).some(key => regex.test(key));\n}",
"score": 41.42964944631376
},
{
"filename": "src/lib/prompts/derive_instruction_prompt.ts",
"retrieved_chunk": "type DerivedInstructionKey = string;\nexport type DerivedInstructionResponse = `export default function ${DerivedInstructionKey}() {`;\nexport function isDerivedInstructionResponse(obj: GuardValidations): boolean {\n return 'string' === typeof obj && derivedInstructionResponseRegex.test(obj);\n}",
"score": 40.962391866275645
}
] | typescript | hasSimilarKey(item, guidedEditKey)
})); |
import { ChatCompletionRequestMessage } from "openai";
import type { GuardValidations } from "../types";
// aHR0cHM6Ly9tYXJ0aW5mb3dsZXIuY29tL2FydGljbGVzLzIwMjMtY2hhdGdwdC14dS1oYW8uaHRtbA==
export const deriveInstructionMessages: ChatCompletionRequestMessage[] = [
{ role: 'system', content: '' },
{ role: 'assistant', content: `{introduction}
The current system is a {system_name}. Tech stack: {tech_stack}. And {testing_tools}.
All codes should be written in the tech stack mentioned above. Requirements should be implemented as {architecture_pattern}.
{view_models_block}
{common_implementation_strategy}
Here is the common implementation strategy for the project:
{strategy_block_which_covers_strategies_relating_to_view_models}
{strategy_block_which_covers_strategies_relating_to_component_implementation}
{strategy_block_which_covers_strategies_relating_to_testing}
{patterns_to_follow}
Here are certain patterns that should be followed when implementing and testing the components:
{test_pattern_guideline_block_1}
{test_pattern_guideline_block_2}
{test_pattern_guideline_block_3}
{feature_requirement}
{feature_name}
Requirement:
{requirement_description}
{acceptance_criteria}
AC1: {criteria1_description}.
AC2: {criteria2_description}.
{solution_guidance}
Provide an overall solution following the guidance mentioned above. Hint, {solution_hint}. Don't generate code. Describe the solution and break it down into a task list based on the guidance mentioned above. We will refer to this task list as our master plan.`}
];
const derivedInstructionResponseRegex = /export default function/igm;
type DerivedInstructionKey = string;
export type DerivedInstructionResponse = `export default function ${DerivedInstructionKey}() {`;
| export function isDerivedInstructionResponse(obj: GuardValidations): boolean { |
return 'string' === typeof obj && derivedInstructionResponseRegex.test(obj);
} | src/lib/prompts/derive_instruction_prompt.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/prompts/file_editor_prompt.ts",
"retrieved_chunk": "9. throw new Error('Missing ts.configRoot.') /* change: edited text */\n\\`\\`\\`\nPlease find the 4 changes above this line.` },\n { role: 'user', content: `\\${prompt1}\n\\${prompt2}\n\\${prompt3}`}\n];\n// const testSystem = 'you are a helpful typescript coding assistant';\n// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown \"```typescript\" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'\nconst fileEditorResponseRegex = /^\\d+./igm;",
"score": 32.3524734040305
},
{
"filename": "src/lib/prompts/create_gen_component_prompt.ts",
"retrieved_chunk": " { role: 'user', content: '${prompt1}' }\n];\nconst generalComponentResponseRegex = /export default/ig;\ntype GeneralComponentKey = string;\nexport type GeneralComponentResponse = `export default function ${GeneralComponentKey}() {`;\nexport function isGeneralComponentResponse(obj: GuardValidations): boolean {\n return 'string' === typeof obj && generalComponentResponseRegex.test(obj);\n}",
"score": 32.242822399696486
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\n// const createTypePrompt = 'Complete the following typescript type with 4-7 unconventionally named properties, using string, number or boolean, starting with its opening bracket, \"type ${prompt1} =';\n// const createTypeMessages = [\n// { role: 'system', content: 'I, TypescriptTypeGeneratorGPT, respond with a code statement declaring a Typescript type, based on the name of a type.' },\n// { role: 'assistant', content: `This message describes how \\${prompt1} will be generated and returned in the next message.\n// 1. Parse Name: You provided a name in the format of ITypeName, \\${prompt1}, which I will evaluate to determine its general informational context.\n// 2. Primary Action: Generate TYPE_DEFINITION of 4-7 unconventionally named properties.\n// 3. Primary Validation: TYPE_DEFINITION is validated as starting with text \"type \\${prompt1} = {\" with the rest of TYPE_DEFINITION to follow.\n// 4. Secondary Validation: Exact response text verified to be formatted in the following pattern:",
"score": 31.091728519753307
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": " @@@\n &&&\n Next steps:\n Give me the desired state and JSON object with code statements using these keywords:\n TARGET_STATE --- <phrase with code terms>\n STATEMENTS_JSON --- <a simple JSON object>\n I'll change the code in the JSON object to reach the target state and create the final array.`},\n { role: 'user', content: ' TARGET_STATE --- ${prompt1}\\n STATEMENTS_JSON --- ${prompt2}' }\n];\nexport type GuidedEditKeyPrefix = 'statement' | 'above' | 'below';",
"score": 30.921023318800135
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "// const testPrompt = 'typescript code that ${prompt1}. only show completely working code. remember to encase your code inside proper markdown \"```typescript\" header, and on the next line, include a unique-description filename such as `#dice-counter.py`.'\nexport const guidedEditMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'I change code from a JSON object to an array based on the target state.' },\n { role: 'assistant', content: `What I need:\n JSON object with code statements\n Desired state of the code statements\n What I do:\n Check which statements in the JSON object can help reach the desired state.\n Keep only useful statements.\n Change the statements to reach the target state. I can update, insert, or remove statements.",
"score": 28.390805578633625
}
] | typescript | export function isDerivedInstructionResponse(obj: GuardValidations): boolean { |
import { isConvertPurposeResult } from "../lib/prompts/convert_purpose_prompt";
import { isCreateApiBackendResult } from "../lib/prompts/create_api_backend_prompt";
import { isCreateApiResult } from "../lib/prompts/create_api_prompt";
import { isGeneralComponentResponse } from "../lib/prompts/create_gen_component_prompt";
import { isCreateTypeResponse } from "../lib/prompts/create_type_prompt";
import { isFileEditorResult } from "../lib/prompts/file_editor_prompt";
import { isGuidedEditResult } from "../lib/prompts/guided_edit_prompt";
import type { GuardValidations } from "../lib/types";
import { processTextWithCodeBlock, stripWrappedCharacter } from "./util";
export function parseChatAttempt<T>(attempt: string): { supportingText: string, message: T } {
const aiRefusalError = /(^i\'m sorry)|(?:ai(?:\s|-)?language(?:\s|-)?model|i(?:'?m| am))(?:[^.]*?)(?:can(?:'?t| not)|unable to)(?:[^.]*?)(?:perform|do|create|provide)/i;
if (aiRefusalError.test(attempt)) {
throw new Error('AI Refusal');
}
const isAbstractWrap = attempt.includes('&&&') && attempt.includes('@@@');
const isBacktickWrap = attempt.includes('```');
if (isAbstractWrap || isBacktickWrap) {
let innerBlockText = '';
let supportingText = '';
if (isBacktickWrap) {
const processedText = processTextWithCodeBlock(attempt);
innerBlockText = processedText.codeBlock;
supportingText = processedText.supportingText;
} else {
const outerBlockStart = attempt.indexOf('&&&') + 3;
const outerBlockEnd = attempt.lastIndexOf('&&&');
const pretextEnd = attempt.indexOf('@@@');
const innerBlockStart = pretextEnd + 3;
const innerBlockEnd = attempt.lastIndexOf('@@@');
const postTextStart = innerBlockEnd + 3;
innerBlockText = attempt.slice(innerBlockStart, innerBlockEnd);
const pretext = attempt.slice(outerBlockStart, pretextEnd);
const posttext = attempt.slice(postTextStart, outerBlockEnd);
supportingText = pretext + '\n' + posttext;
console.log({
ABSTRACTMATCHFOUND: true,
outerBlockStart,
outerBlockEnd,
pretextEnd,
innerBlockStart,
innerBlockEnd,
postTextStart
});
}
console.log({ supportingText, innerBlockText })
if (!innerBlockText.length) {
throw new Error('cannot parse Block structure is not valid.');
}
try {
if (innerBlockText.startsWith('{') || innerBlockText.startsWith('[')) {
JSON.parse(innerBlockText);
}
} catch (error) {
const err = error as Error;
throw new Error('cannot parse json.' + err.message)
}
console.log("Validating innerblocktext : ", innerBlockText)
const result = validateTypedResponse<T>(innerBlockText);
return { message: result, supportingText };
}
attempt = stripWrappedCharacter(attempt);
console.log("Parsing a basic attempt: ", attempt);
const result = validateTypedResponse<T>(attempt);
return { message: result, supportingText: '' };
}
export let responseValidators = [
isConvertPurposeResult,
isFileEditorResult,
isGuidedEditResult,
isCreateTypeResponse,
isCreateApiResult,
isCreateApiBackendResult,
isGeneralComponentResponse
];
export function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void {
responseValidators = responseValidators.concat(validators);
}
export function validateTypedResponse<T>(response: string): T {
if (!response) {
throw new Error('empty response');
}
try {
let body: GuardValidations = response;
try {
body = JSON.parse(response);
} catch (error) {}
for (const tg of responseValidators) {
if | (body && tg(body)) { |
return body as T;
}
console.log('Guard function:', tg.name, 'Result:', tg(body));
}
} catch (error) { }
throw new Error('bad chat format');
} | src/server/parser.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/git/manage_pull_request.ts",
"retrieved_chunk": " const existingPr = prListOutput.find(pr => pr.headRefName === branch);\n if (!existingPr) {\n execSync(`gh pr create --title \"${title}\" --body \"${body}\" --head \"${branch}\" --base \"${config.git.source}\"`, { cwd: config.git.rootPath });\n } else {\n execSync(`gh pr review ${existingPr.number} --comment -b \"${title}\\n\\n${body}\"`, { cwd: config.git.rootPath }); \n }\n return `guided edit process sucessfully ${existingPr?.number ? 'updated' : 'created'} ${existingPr?.url}`;\n}",
"score": 26.586164012709737
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " aiResponse.failures.push(imparsable);\n throw new Error(imparsable);\n }\n return await resolveAttempt(repeatedAttempt, retriesRemaining - 1);\n }\n const resolveIssue = 'Critical chat parse error or could not resolve a valid response after ' + retries + ' attempts. ' + (err.message ? 'Parsing error: ' + err.message : '');\n aiResponse.failures.push(resolveIssue);\n throw new Error(resolveIssue);\n }\n }",
"score": 26.302927914072896
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "export function getConfigFromPath(configPath: string): Config {\n let optionalConfig: Config;\n try {\n const configText = fs.readFileSync(configPath, 'utf-8');\n optionalConfig = JSON.parse(configText) as Config;\n } catch (error) {\n optionalConfig = defaultConfig;\n }\n return optionalConfig;\n}",
"score": 24.351314858405235
},
{
"filename": "src/server/git/manage_pull_request.ts",
"retrieved_chunk": "import { execSync } from \"child_process\";\nimport { gitCheck } from \"./check_git_cli\";\nimport { getConfig } from \"../config\";\nexport async function managePullRequest(branch: string, title: string, body: string) {\n gitCheck();\n const config = getConfig();\n if (!config.git.rootPath) {\n throw 'Missing config.git.rootPath.'\n }\n const prListOutput = JSON.parse(Buffer.from(execSync(`gh pr list --state open --base ${config.git.source} --json number,headRefName,url`, { cwd: config.git.rootPath })).toString()) as { number: number, headRefName: string, url: string }[];",
"score": 20.846400059808303
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " if (!originalFileContents) throw 'File not found.';\n const lined = originalFileContents.split('\\n').map((l, i) => `${i + 1}. ${l}`);\n console.log({ lined, fileName, suggestedEdits });\n const response = await useAi<FileEditorResponse>(IPrompts.FILE_EDITOR, fileName, suggestedEdits.join(' '), lined.join('\\n'));\n console.log({ EDITOR_FINISHED: response.message });\n const editedLines: Record<string, string> = response.message.split('\\n').reduce((m, d) => {\n const match = d.match(/^\\d+. /);\n if (match) {\n console.log({ match })\n return ({",
"score": 19.620378574341654
}
] | typescript | (body && tg(body)) { |
import fs from 'fs';
import path from "path";
import { sync } from 'fast-glob';
import { isCalledWithNpx, isCliRunning } from "./config";
import languages from "../lib/languages";
import type { OpenAIRequestShapes } from './types';
import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from 'openai';
const langValues = Object.values(languages);
export const codeGPTPrecursor = 'You are BacktickGPT, providing only typescript code responses wrapped with 3 backticks before and after.';
export function deepClone<T>(obj: T): T {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map((item) => deepClone(item) as T) as unknown as T;
}
const result: Record<string, unknown> = {};
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = deepClone((obj as Record<string, unknown>)[key]);
}
}
return result as T;
}
export const isValidName = (name: string): boolean => {
const regex = /^I[A-Z][a-zA-Z]*$/;
return regex.test(name);
};
export const toSnakeCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);
};
export const toTitleCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
};
export function extractCodeBlock(inputString: string, delimeter: string = '```', languages: string[] = ['typescript', 'json', 'jsx', 'tsx']) {
const langStartTag = (language: string) => language ? `${delimeter}${language}` : delimeter;
for (const language of languages) {
const startTag = langStartTag(language);
if (inputString.includes(startTag)) {
return {
codeBlock: inputString.split(startTag)[1].split(delimeter)[0],
index: inputString.indexOf(startTag) + startTag.length,
};
}
}
if (inputString.includes(delimeter)) {
const index = inputString.indexOf(delimeter) + delimeter.length;
return {
codeBlock: inputString.split(delimeter)[1],
index,
};
}
return {
codeBlock: inputString,
index: 0,
};
};
export function extractCodeBlockPre(inputString: string, index: number): string {
return inputString.substring(0, index)?.trim() || '';
}
export function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {
return inputString.substring(index).split(delimeter)[1]?.trim() || '';
}
export function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {
const { codeBlock, index } = extractCodeBlock(inputString);
const preText = extractCodeBlockPre(inputString, index);
const postText = extractCodeBlockPost(inputString, index);
return {
codeBlock,
supportingText: preText + ' ' + postText,
};
}
export function stripWrappedCharacter(inputString: string, wrappedCharacters: string[] = ['"', "'"]): string {
for (const char of wrappedCharacters) {
if (inputString.startsWith(char)) inputString = inputString.slice(1);
if (inputString.endsWith(char)) inputString = inputString.substring(0, inputString.length - 1);
}
return inputString;
}
export function sanitizeName(input: string): string {
// Trim whitespaces and replace consecutive spaces with a single dash
const trimmed = input.trim();
// Remove invalid characters: ~ ^ : ? * [ ] @ { } \ /
const sanitized = trimmed.replace(/[~^:?"*\[\]@{}\\/]+/g, '');
// Limit branch name length to 100 characters
const maxLength = 100;
const shortened = sanitized.slice(0, maxLength);
// Remove leading and trailing period (.)
const noLeadingTrailingPeriods = shortened.replace(/(^\.+|\.+$)/g, '');
// Remove leading and trailing forward slash (-)
const result = noLeadingTrailingPeriods.replace(/(^-+|-+$)/g, '');
return result;
}
export function ensureKeysAreQuoted(jsonString: string): string {
const unquotedKeysRegex = /([{,]\s*)(\w+)\s*:/g;
function quoteKeys(match: unknown, prefix: string, key: string) {
return `${prefix}"${key}":`;
}
return jsonString.replace(unquotedKeysRegex, quoteKeys);
}
export function typeDefinitionToSentence(typeDefinition: string): string {
const typeNameMatch = typeDefinition.match(/export type (\w+)/);
if (!typeNameMatch) {
return 'Invalid type definition provided.';
}
const typeName = typeNameMatch[1];
const properties = [];
const propertyRegex = /(\w+)\s*:\s*([^;]+);/g;
let match;
while ((match = propertyRegex.exec(typeDefinition)) !== null) {
properties.push({ key: match[1], type: match[2].trim().replace(/\s+/g, ' ') });
}
if (properties.length > 0) {
const propertiesDescription = properties
.map((property) => `${property.key} as a ${property.type}`)
.join(', ');
return `${typeName} defines ${propertiesDescription}.`;
} else {
const recordMatch = typeDefinition.match(/Record<(.+),\s*(.+)>/);
if (recordMatch) {
return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;
}
}
return 'Unable to parse the type definition.';
}
export function getDirPathOf(filePath: string) {
return path.dirname(filePath)
}
export function generateTempFilePath(dir: string, name: string) {
return path.join(dir, `${name}-${Date.now()}.json`)
}
export function getRootDir() {
return isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../');
}
export function getPathOf(name: string, baseDir?: string): string {
return path.join(baseDir || getRootDir(), name);
}
export function getFileParser(fileName: string) {
const extension = path.extname(fileName);
const parser = langValues.find(l => l.fileExtension.includes(extension));
if (!parser) throw 'That parser is undefined!';
return | parser.parserName; |
}
export function getFileFromDir(file: string, dir: string = __dirname) {
const files = fs.readdirSync(dir);
const fileName = files.find(f => f.startsWith(file));
if (!fileName) throw 'File not found.';
return fs.readFileSync(path.join(dir, fileName), { encoding: 'utf-8' })
}
export function getTargetFile(targetFile: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string | null {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return files.length > 0 ? fileContent : null;
}
export function saveTargetFile(targetFile: string, contents: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.writeFileSync(files[0], contents, { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return 'file saved';
}
const excludeDirectories = [
'node_modules',
'vendor',
'dist',
'build',
'.git',
'.svn',
// add other directories to exclude
];
export function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest {
return 'messages' in obj;
}
export function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {
return 'prompt' in obj;
}
export function isModerationRequest(obj: OpenAIRequestShapes): obj is CreateModerationRequest {
return 'input' in obj;
} | src/server/util.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// import TreeSitter, { SyntaxNode, Tree } from 'tree-sitter';\n// import path from 'path';\n// import languages from '../languages';\n// import { getFileFromDir } from '../util';\n// import { LinearizedStatement } from '../types';\n// import { getGrammarPatterns } from './ast';\n// const langValues = Object.values(languages);\n// export async function getStatements(fileName: string): Promise<LinearizedStatement[]> {\n// const extension = path.extname(fileName).slice(1);\n// const langParser = langValues.find(lang => lang.fileExtension.includes(extension));",
"score": 50.46533641085258
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// if (!langParser) throw 'You found an unsupported parser!';\n// const imported = await import(langParser.parserName);\n// const masterGrammars = langParser.parserVariant ? imported.default[langParser.parserVariant] : imported.default;\n// const parser = new TreeSitter();\n// parser.setLanguage(masterGrammars);\n// const code = getFileFromDir(fileName);\n// const parsed = parser.parse(code);\n// const nodeTypes = masterGrammars.nodeTypeInfo.flatMap(getGrammarPatterns);\n// walkNode(parsed.rootNode);\n// return getNodesOfType(parsed, nodeTypes);",
"score": 33.065138681104465
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " if (!originalFileContents) throw 'File not found.';\n const lined = originalFileContents.split('\\n').map((l, i) => `${i + 1}. ${l}`);\n console.log({ lined, fileName, suggestedEdits });\n const response = await useAi<FileEditorResponse>(IPrompts.FILE_EDITOR, fileName, suggestedEdits.join(' '), lined.join('\\n'));\n console.log({ EDITOR_FINISHED: response.message });\n const editedLines: Record<string, string> = response.message.split('\\n').reduce((m, d) => {\n const match = d.match(/^\\d+. /);\n if (match) {\n console.log({ match })\n return ({",
"score": 27.35587947187043
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": "export function processFile(fileName: string) {\n activeTasks++;\n buildAndCopyFile(fileName);\n runExtractionScript();\n const localModsPath = 'path/to/your/local_modifications_file';\n copyModifications(localModsPath);\n runModificationScript();\n copyModifiedFileToLocal(fileName);\n activeTasks--;\n if (!activeTasks) {",
"score": 25.776823943403336
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 24.92149191780898
}
] | typescript | parser.parserName; |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
| const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements)); |
const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {});
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 28.988733863404057
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n }\n try {\n const generatedApiBackend = await useAi<CreateApiBackendResult>(IPrompts.CREATE_API_BACKEND, generatedType + ' ' + apiEndpoints.join(' '))\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`;\n sourceFile.insertText(sourceFile.getEnd(), `${comment}${generatedApiBackend.message}\\n\\n`);\n sourceFile.fixMissingImports();\n await project.save();\n } catch (error) {\n console.error(error);",
"score": 28.499773092854348
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " const variables = sourceFile.getVariableDeclarations();\n const apiEndpoints: string[] = [];\n for (const v of variables) {\n if (v.getName().endsWith('Api')) {\n const initializer = v.getInitializer();\n if (initializer) {\n initializer.getType().getProperties().forEach(p => {\n apiEndpoints.push(p.getName())\n });\n }",
"score": 23.125589720229446
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// export function getNodesOfType(rootNode: Tree, nodeTypes: string[]): LinearizedStatement[] {\n// let nodeIdCounter = 0;\n// const usedNodes: Map<string, string> = new Map();\n// const nodes: LinearizedStatement[] = [];\n// function visitNode(node: SyntaxNode, parentId?: number): void {\n// const shouldBeParsed = nodeTypes.includes(node.type);\n// if (shouldBeParsed) {\n// const nodeId = nodeIdCounter++;\n// let content = node.text;\n// if (parentId !== undefined) {",
"score": 22.720413686388998
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " index: 0,\n };\n};\nexport function extractCodeBlockPre(inputString: string, index: number): string {\n return inputString.substring(0, index)?.trim() || '';\n}\nexport function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {\n return inputString.substring(index).split(delimeter)[1]?.trim() || '';\n}\nexport function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {",
"score": 21.874523656948078
}
] | typescript | const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements)); |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = | await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements)); |
const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {});
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 24.332448034370465
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n }\n try {\n const generatedApiBackend = await useAi<CreateApiBackendResult>(IPrompts.CREATE_API_BACKEND, generatedType + ' ' + apiEndpoints.join(' '))\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`;\n sourceFile.insertText(sourceFile.getEnd(), `${comment}${generatedApiBackend.message}\\n\\n`);\n sourceFile.fixMissingImports();\n await project.save();\n } catch (error) {\n console.error(error);",
"score": 21.981124505785242
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " index: 0,\n };\n};\nexport function extractCodeBlockPre(inputString: string, index: number): string {\n return inputString.substring(0, index)?.trim() || '';\n}\nexport function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {\n return inputString.substring(index).split(delimeter)[1]?.trim() || '';\n}\nexport function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {",
"score": 21.874523656948078
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// export function getNodesOfType(rootNode: Tree, nodeTypes: string[]): LinearizedStatement[] {\n// let nodeIdCounter = 0;\n// const usedNodes: Map<string, string> = new Map();\n// const nodes: LinearizedStatement[] = [];\n// function visitNode(node: SyntaxNode, parentId?: number): void {\n// const shouldBeParsed = nodeTypes.includes(node.type);\n// if (shouldBeParsed) {\n// const nodeId = nodeIdCounter++;\n// let content = node.text;\n// if (parentId !== undefined) {",
"score": 21.447525428253805
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " }\n if (inputString.includes(delimeter)) {\n const index = inputString.indexOf(delimeter) + delimeter.length;\n return {\n codeBlock: inputString.split(delimeter)[1],\n index,\n };\n }\n return {\n codeBlock: inputString,",
"score": 19.81716796487592
}
] | typescript | await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements)); |
import fs from 'fs';
import path from "path";
import { sync } from 'fast-glob';
import { isCalledWithNpx, isCliRunning } from "./config";
import languages from "../lib/languages";
import type { OpenAIRequestShapes } from './types';
import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from 'openai';
const langValues = Object.values(languages);
export const codeGPTPrecursor = 'You are BacktickGPT, providing only typescript code responses wrapped with 3 backticks before and after.';
export function deepClone<T>(obj: T): T {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map((item) => deepClone(item) as T) as unknown as T;
}
const result: Record<string, unknown> = {};
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = deepClone((obj as Record<string, unknown>)[key]);
}
}
return result as T;
}
export const isValidName = (name: string): boolean => {
const regex = /^I[A-Z][a-zA-Z]*$/;
return regex.test(name);
};
export const toSnakeCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);
};
export const toTitleCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
};
export function extractCodeBlock(inputString: string, delimeter: string = '```', languages: string[] = ['typescript', 'json', 'jsx', 'tsx']) {
const langStartTag = (language: string) => language ? `${delimeter}${language}` : delimeter;
for (const language of languages) {
const startTag = langStartTag(language);
if (inputString.includes(startTag)) {
return {
codeBlock: inputString.split(startTag)[1].split(delimeter)[0],
index: inputString.indexOf(startTag) + startTag.length,
};
}
}
if (inputString.includes(delimeter)) {
const index = inputString.indexOf(delimeter) + delimeter.length;
return {
codeBlock: inputString.split(delimeter)[1],
index,
};
}
return {
codeBlock: inputString,
index: 0,
};
};
export function extractCodeBlockPre(inputString: string, index: number): string {
return inputString.substring(0, index)?.trim() || '';
}
export function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {
return inputString.substring(index).split(delimeter)[1]?.trim() || '';
}
export function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {
const { codeBlock, index } = extractCodeBlock(inputString);
const preText = extractCodeBlockPre(inputString, index);
const postText = extractCodeBlockPost(inputString, index);
return {
codeBlock,
supportingText: preText + ' ' + postText,
};
}
export function stripWrappedCharacter(inputString: string, wrappedCharacters: string[] = ['"', "'"]): string {
for (const char of wrappedCharacters) {
if (inputString.startsWith(char)) inputString = inputString.slice(1);
if (inputString.endsWith(char)) inputString = inputString.substring(0, inputString.length - 1);
}
return inputString;
}
export function sanitizeName(input: string): string {
// Trim whitespaces and replace consecutive spaces with a single dash
const trimmed = input.trim();
// Remove invalid characters: ~ ^ : ? * [ ] @ { } \ /
const sanitized = trimmed.replace(/[~^:?"*\[\]@{}\\/]+/g, '');
// Limit branch name length to 100 characters
const maxLength = 100;
const shortened = sanitized.slice(0, maxLength);
// Remove leading and trailing period (.)
const noLeadingTrailingPeriods = shortened.replace(/(^\.+|\.+$)/g, '');
// Remove leading and trailing forward slash (-)
const result = noLeadingTrailingPeriods.replace(/(^-+|-+$)/g, '');
return result;
}
export function ensureKeysAreQuoted(jsonString: string): string {
const unquotedKeysRegex = /([{,]\s*)(\w+)\s*:/g;
function quoteKeys(match: unknown, prefix: string, key: string) {
return `${prefix}"${key}":`;
}
return jsonString.replace(unquotedKeysRegex, quoteKeys);
}
export function typeDefinitionToSentence(typeDefinition: string): string {
const typeNameMatch = typeDefinition.match(/export type (\w+)/);
if (!typeNameMatch) {
return 'Invalid type definition provided.';
}
const typeName = typeNameMatch[1];
const properties = [];
const propertyRegex = /(\w+)\s*:\s*([^;]+);/g;
let match;
while ((match = propertyRegex.exec(typeDefinition)) !== null) {
properties.push({ key: match[1], type: match[2].trim().replace(/\s+/g, ' ') });
}
if (properties.length > 0) {
const propertiesDescription = properties
.map((property) => `${property.key} as a ${property.type}`)
.join(', ');
return `${typeName} defines ${propertiesDescription}.`;
} else {
const recordMatch = typeDefinition.match(/Record<(.+),\s*(.+)>/);
if (recordMatch) {
return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;
}
}
return 'Unable to parse the type definition.';
}
export function getDirPathOf(filePath: string) {
return path.dirname(filePath)
}
export function generateTempFilePath(dir: string, name: string) {
return path.join(dir, `${name}-${Date.now()}.json`)
}
export function getRootDir() {
return isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../');
}
export function getPathOf(name: string, baseDir?: string): string {
return path.join(baseDir || getRootDir(), name);
}
export function getFileParser(fileName: string) {
const extension = path.extname(fileName);
const parser = langValues.find(l => l.fileExtension.includes(extension));
if (!parser) throw 'That parser is undefined!';
return parser.parserName;
}
export function getFileFromDir(file: string, dir: string = __dirname) {
const files = fs.readdirSync(dir);
const fileName = files.find(f => f.startsWith(file));
if (!fileName) throw 'File not found.';
return fs.readFileSync(path.join(dir, fileName), { encoding: 'utf-8' })
}
export function getTargetFile(targetFile: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string | null {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return files.length > 0 ? fileContent : null;
}
export function saveTargetFile(targetFile: string, contents: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.writeFileSync(files[0], contents, { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return 'file saved';
}
const excludeDirectories = [
'node_modules',
'vendor',
'dist',
'build',
'.git',
'.svn',
// add other directories to exclude
];
export function | isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest { |
return 'messages' in obj;
}
export function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {
return 'prompt' in obj;
}
export function isModerationRequest(obj: OpenAIRequestShapes): obj is CreateModerationRequest {
return 'input' in obj;
} | src/server/util.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "export function isChatResponse<T>(obj: GuardValidations): obj is ChatResponse<T> {\n return 'object' === typeof obj && 'message' in obj && Array.isArray(obj.message);\n}\nexport function isCompletionResponse(obj: GuardValidations): obj is CompletionResponse {\n return 'object' === typeof obj && 'message' in obj && 'string' === typeof obj.message;\n}\nexport function isModerationResponse(obj: GuardValidations): obj is ModerationResponse {\n return 'object' === typeof obj && 'input' in obj;\n}",
"score": 17.951124978430062
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 17.1660326337909
},
{
"filename": "src/lib/prompts/create_api_prompt.ts",
"retrieved_chunk": "export type CreateApiResult = `const ${CreateApiKey}Api =`;\nexport function isCreateApiResult(obj: GuardValidations): obj is CreateApiResult {\n return 'string' === typeof obj && createApiFormat.test(obj);\n}",
"score": 16.212343236616128
},
{
"filename": "src/server/types.ts",
"retrieved_chunk": "import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from \"openai\";\nexport type OpenAIRequestShapes = CreateChatCompletionRequest | CreateCompletionRequest | CreateModerationRequest;",
"score": 15.938970814112523
},
{
"filename": "src/lib/prompts/create_api_backend_prompt.ts",
"retrieved_chunk": " 6. Response Technique is the following verbatim text with variables replaced by <>: &&&@@@<RESPONSE_BODY>@@@&&&\n 7. Validate Response: The response returned to the user follows the exact format of Step 6: eg. &&&@@@const customizedApiHandlers: ApiHandler<typeof customizedApi> = {\\n transferred functionality customized around FILE_RELATED_TYPE\\n }@@@&&&` },\n { role: 'user', content: 'FILE_RELATED_TYPE=\\${prompt1}' }\n];\nconst createApiFormat = /^const\\s+\\w+ApiHandlers:\\s+ApiHandler/gim;\ntype CreateApiBackendKey = string;\nexport type CreateApiBackendResult = `const ${CreateApiBackendKey}ApiHandlers: ApiHandler`;\nexport function isCreateApiBackendResult(obj: GuardValidations): obj is CreateApiBackendResult {\n return 'string' === typeof obj && createApiFormat.test(obj);\n}",
"score": 13.310928649723504
}
] | typescript | isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest { |
#!/usr/bin/env node
import yargs from 'yargs/yargs';
import { config, saveConfig, getConfigValue, checkConfigExists } from './config';
import * as spells from './spells';
import { IPrompts } from '../lib/prompts';
const parser = yargs(process.argv.slice(2))
// .options({
// 'config': {
// alias: 'c',
// describe: 'Path to the configuration file',
// default: 'config.json',
// type: 'string',
// },
// 'verbose': {
// alias: 'v',
// describe: 'Display verbose output',
// default: false,
// type: 'boolean',
// },
// })
.command(
'set [key] [value]',
'Set a configuration value',
(yargs) => {
return yargs.positional('key', {
describe: 'Configuration key to set',
type: 'string',
}).positional('value', {
describe: 'Value to set for the configuration key',
type: 'string',
});
},
(argv) => {
checkConfigExists();
if (!argv.key) throw new Error('key required');
const keys = argv.key.split('.');
| const [current, lastKey] = getConfigValue(config, keys); |
current[lastKey] = argv.value || '';
saveConfig();
}
)
.command(
'use-ai [promptType] [prompts...]',
'Use AI with the specified prompts',
(yargs) => {
return yargs
.positional('promptType', {
describe: 'The type of prompt to use',
default: undefined,
type: 'string',
})
.positional('prompts', {
describe: 'Prompts',
demandOption: true,
type: 'string',
nargs: 1,
array: true,
});
},
async (argv) => {
await spells.useAi(argv.promptType as IPrompts | undefined, ...argv.prompts)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'guided-edit [fileNameWithInstructions] [optionalName]',
'Run guided edit',
(yargs) => {
return yargs
.positional('fileNameWithInstructions', {
describe: 'File name with instructions',
type: 'string',
demandOption: true
})
.positional('optionalName', {
describe: 'Optional name',
type: 'string',
})
.options({
'commit': {
type: 'boolean',
description: 'Will commit edits to the generated branch',
default: true,
},
'pull-request': {
type: 'boolean',
description: 'Will create and add to 1 pull request per generated branch',
default: true,
},
});
},
async (argv) => {
await spells.guidedEdit(argv.fileNameWithInstructions, argv.optionalName)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'file-editor <fileName> [instructions...]',
'Edit any file',
(yargs) => {
return yargs
.positional('fileName', {
describe: 'File Name',
type: 'string',
demandOption: true
})
.positional('instructions', {
describe: 'File name with instructions',
type: 'string',
array: true,
demandOption: true
});
},
async (argv) => {
await spells.fileEditor(argv.fileName, ...argv.instructions)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-component [description]',
'Create a component',
(yargs) => {
return yargs
.positional('description', {
describe: 'Component description',
demandOption: true,
type: 'string',
});
},
async (argv) => {
await spells.createComponent(argv.description)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-api [typeName]',
'Create an API',
(yargs) => {
return yargs
.positional('typeName', {
describe: 'API type name',
demandOption: true,
type: 'string',
});
},
async (argv) => {
const generatedType = await spells.createType(argv.typeName)
await spells.createApi(argv.typeName, generatedType)
.then((result) => console.log(result))
.catch((error) => console.error(error));
await spells.createApiBackend(argv.typeName, generatedType);
}
)
.demandCommand(1, 'You need at least one command before moving on')
.help()
.alias('h', 'help')
.strict();
(async () => {
await parser.argv;
})(); | src/server/cli.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Helper function\nexport function getConfigValue(config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] {\n let current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config;\n for (let i = 0; i < keys.length - 1; i++) {\n if (!isConfigNestedObject(current[keys[i]])) {\n throw new Error('invalid config key');\n }\n current = current[keys[i]] as Record<string, ConfigPropTypes>;\n }\n return [current, keys[keys.length - 1]];",
"score": 45.38611363123588
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// }\n// export function walkNode(rootNode: SyntaxNode) {\n// const linearText: Record<number, string> = {};\n// const nodes: SyntaxNode[] = [];\n// function innerWalk (node: SyntaxNode) {\n// for (const child of node.children) {\n// const key = child.startPosition.row;\n// if (!linearText[key]) {\n// linearText[key] = \"\";\n// }",
"score": 28.301287794385104
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n if (Array.isArray(obj)) {\n return obj.map((item) => deepClone(item) as T) as unknown as T;\n }\n const result: Record<string, unknown> = {};\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = deepClone((obj as Record<string, unknown>)[key]);",
"score": 27.019183968406644
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " const edit = key && editedLines[key as keyof typeof editedLines];\n if (edit) {\n return edit.replace(regex, ''); \n }\n return l.slice(match?match[0].length:0);\n }).filter(l => l?.length > 0).join('\\n');\n console.log({ lined, editedLines, editedFile, editNum: Object.keys(editedLines).length });\n const saved = saveTargetFile(fileName, editedFile);\n return saved;\n}",
"score": 26.16400470058798
},
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// linearText[key] += (linearText[key] ? \" \" : \"\") + child.text;\n// // Recursion for deeper levels\n// if (child.children && child.children.length > 0 && !linearText[key].includes(child.children[0].text)) {\n// innerWalk(child);\n// }\n// }\n// }\n// innerWalk(rootNode)\n// return nodes;\n// }",
"score": 23.51114200203039
}
] | typescript | const [current, lastKey] = getConfigValue(config, keys); |
// config.ts
import fs from 'fs';
import path from 'path';
import type { Config as RootConfig, ConfigPropTypes } from '../lib/types';
import { isConfigNestedObject } from '../lib/util';
export const isCliRunning = process.argv[1].includes('bin/src/cli.js');
export const isCalledWithNpx = process.env.npm_execpath && /npx(-cli\.js)?$/.test(process.env.npm_execpath);
const normalPath = path.join(__dirname, `${isCliRunning ? '../..' : isCalledWithNpx ? process.cwd() : '..'}/config.json`)
const npxPath = path.join(process.cwd(), 'config.json')
export const configFilePath = isCalledWithNpx ? npxPath : normalPath;
// Default configuration values
export const defaultConfig = {
ai: { retries: '3', logFile: 'results.json', chatModel: 'gpt-3.5-turbo', completionModel: 'curie' },
ts: { configPath: '', typeDir: '', compDir: '' },
git: { rootPath: '', source: 'main', remote: 'origin' },
user: { name: 'wizapp' }
};
type Config = RootConfig<typeof defaultConfig>;
// Load existing configuration or create a new file with default values
export let config = defaultConfig;
export function checkConfigExists() {
if (fs.existsSync(configFilePath)) {
const rawData = fs.readFileSync(configFilePath);
config = JSON.parse(rawData.toString());
} else {
fs.writeFileSync(configFilePath, JSON.stringify(defaultConfig, null, 2));
config = defaultConfig;
}
}
checkConfigExists();
// Function to save the configuration
export function saveConfig(): void {
fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
}
export function setConfig(newConfig: Config): void {
config = newConfig;
}
export function getConfig(): Config {
return config;
}
export function getConfigFromPath(configPath: string): Config {
let optionalConfig: Config;
try {
const configText = fs.readFileSync(configPath, 'utf-8');
optionalConfig = JSON.parse(configText) as Config;
} catch (error) {
optionalConfig = defaultConfig;
}
return optionalConfig;
}
// Helper function
export function getConfigValue(config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] {
let | current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config; |
for (let i = 0; i < keys.length - 1; i++) {
if (!isConfigNestedObject(current[keys[i]])) {
throw new Error('invalid config key');
}
current = current[keys[i]] as Record<string, ConfigPropTypes>;
}
return [current, keys[keys.length - 1]];
} | src/server/config.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/types.ts",
"retrieved_chunk": "export type ConfigPropTypes = string;\nexport type Config<T = Record<string, Record<string, ConfigPropTypes>>> = T;\nexport type CurrentType = ConfigPropTypes | Config;\nexport type GuardValidations = Record<string, unknown> | Record<string, unknown>[] | string\nexport type OpenAIResults = {\n model?: string;\n timestamp: Date;\n prompts?: string[];\n promptType: string;\n promptTemplate: string | undefined;",
"score": 71.51415306436395
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 41.90846069465078
},
{
"filename": "src/lib/index.ts",
"retrieved_chunk": "export * from './prompts';\nexport * from './languages';\nexport * from './util';\nexport type {\n Config,\n ConfigPropTypes,\n GuardValidations,\n ChatResponse,\n CompletionResponse,\n ModerationResponse,",
"score": 37.26387721916805
},
{
"filename": "src/lib/prompts/prompt_utils.ts",
"retrieved_chunk": "export function getSuggestionPrompt(prompt: string) {\n return `Generate 5 ${prompt}; Result is 1-3 words separated by |. Here are some examples: `;\n}\nexport function generateExample(prompt: string, result: string = '') {\n return `Phrase: ${prompt}\\nResult: ${result}`;\n}\nexport function hasSimilarKey(obj: Record<string, unknown>, regex: RegExp): boolean {\n return Object.keys(obj).some(key => regex.test(key));\n}",
"score": 25.356292057037457
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n if (Array.isArray(obj)) {\n return obj.map((item) => deepClone(item) as T) as unknown as T;\n }\n const result: Record<string, unknown> = {};\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = deepClone((obj as Record<string, unknown>)[key]);",
"score": 24.64479348211075
}
] | typescript | current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config; |
#!/usr/bin/env node
import yargs from 'yargs/yargs';
import { config, saveConfig, getConfigValue, checkConfigExists } from './config';
import * as spells from './spells';
import { IPrompts } from '../lib/prompts';
const parser = yargs(process.argv.slice(2))
// .options({
// 'config': {
// alias: 'c',
// describe: 'Path to the configuration file',
// default: 'config.json',
// type: 'string',
// },
// 'verbose': {
// alias: 'v',
// describe: 'Display verbose output',
// default: false,
// type: 'boolean',
// },
// })
.command(
'set [key] [value]',
'Set a configuration value',
(yargs) => {
return yargs.positional('key', {
describe: 'Configuration key to set',
type: 'string',
}).positional('value', {
describe: 'Value to set for the configuration key',
type: 'string',
});
},
(argv) => {
checkConfigExists();
if (!argv.key) throw new Error('key required');
const keys = argv.key.split('.');
const [current, lastKey] = getConfigValue(config, keys);
current[lastKey] = argv.value || '';
saveConfig();
}
)
.command(
'use-ai [promptType] [prompts...]',
'Use AI with the specified prompts',
(yargs) => {
return yargs
.positional('promptType', {
describe: 'The type of prompt to use',
default: undefined,
type: 'string',
})
.positional('prompts', {
describe: 'Prompts',
demandOption: true,
type: 'string',
nargs: 1,
array: true,
});
},
async (argv) => {
await spells.useAi(argv.promptType as IPrompts | undefined, ...argv.prompts)
.then | ((result) => console.log(result))
.catch((error) => console.error(error)); |
}
)
.command(
'guided-edit [fileNameWithInstructions] [optionalName]',
'Run guided edit',
(yargs) => {
return yargs
.positional('fileNameWithInstructions', {
describe: 'File name with instructions',
type: 'string',
demandOption: true
})
.positional('optionalName', {
describe: 'Optional name',
type: 'string',
})
.options({
'commit': {
type: 'boolean',
description: 'Will commit edits to the generated branch',
default: true,
},
'pull-request': {
type: 'boolean',
description: 'Will create and add to 1 pull request per generated branch',
default: true,
},
});
},
async (argv) => {
await spells.guidedEdit(argv.fileNameWithInstructions, argv.optionalName)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'file-editor <fileName> [instructions...]',
'Edit any file',
(yargs) => {
return yargs
.positional('fileName', {
describe: 'File Name',
type: 'string',
demandOption: true
})
.positional('instructions', {
describe: 'File name with instructions',
type: 'string',
array: true,
demandOption: true
});
},
async (argv) => {
await spells.fileEditor(argv.fileName, ...argv.instructions)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-component [description]',
'Create a component',
(yargs) => {
return yargs
.positional('description', {
describe: 'Component description',
demandOption: true,
type: 'string',
});
},
async (argv) => {
await spells.createComponent(argv.description)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-api [typeName]',
'Create an API',
(yargs) => {
return yargs
.positional('typeName', {
describe: 'API type name',
demandOption: true,
type: 'string',
});
},
async (argv) => {
const generatedType = await spells.createType(argv.typeName)
await spells.createApi(argv.typeName, generatedType)
.then((result) => console.log(result))
.catch((error) => console.error(error));
await spells.createApiBackend(argv.typeName, generatedType);
}
)
.demandCommand(1, 'You need at least one command before moving on')
.help()
.alias('h', 'help')
.strict();
(async () => {
await parser.argv;
})(); | src/server/cli.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " JSON.parse(innerBlockText);\n }\n } catch (error) {\n const err = error as Error;\n throw new Error('cannot parse json.' + err.message)\n }\n console.log(\"Validating innerblocktext : \", innerBlockText)\n const result = validateTypedResponse<T>(innerBlockText);\n return { message: result, supportingText };\n }",
"score": 35.009438805533705
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n }\n try {\n const generatedApiBackend = await useAi<CreateApiBackendResult>(IPrompts.CREATE_API_BACKEND, generatedType + ' ' + apiEndpoints.join(' '))\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`;\n sourceFile.insertText(sourceFile.getEnd(), `${comment}${generatedApiBackend.message}\\n\\n`);\n sourceFile.fixMissingImports();\n await project.save();\n } catch (error) {\n console.error(error);",
"score": 30.35171753680551
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " return JSON.parse(result.toString());\n } catch (error) {\n console.error('Error parsing JSON from extraction script:', error);\n return [];\n }\n}\nexport function copyContentsToDocker(fileName: string, content: string) {\n const tempContentPath = getTempFilePath(fileName, content);\n execSync(`docker cp ${tempContentPath} ${containerName}:/app/${fileName}`)\n}",
"score": 29.85679145362691
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 26.40839086134223
},
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " await git.checkoutBranch(generatedBranch, config.git.source);\n await git.push(config.git.remote, generatedBranch, ['--set-upstream', generatedBranch])\n } catch (error) {\n const err = error as Error;\n if (err.message.includes('A branch named') && err.message.includes('already exists')) {\n console.log('Checking out existing generated branch ', generatedBranch);\n await git.checkout(generatedBranch);\n console.log('Pulling generated branch.');\n await git.pull(config.git.remote, generatedBranch);\n }",
"score": 26.23047404970567
}
] | typescript | ((result) => console.log(result))
.catch((error) => console.error(error)); |
import { isConvertPurposeResult } from "../lib/prompts/convert_purpose_prompt";
import { isCreateApiBackendResult } from "../lib/prompts/create_api_backend_prompt";
import { isCreateApiResult } from "../lib/prompts/create_api_prompt";
import { isGeneralComponentResponse } from "../lib/prompts/create_gen_component_prompt";
import { isCreateTypeResponse } from "../lib/prompts/create_type_prompt";
import { isFileEditorResult } from "../lib/prompts/file_editor_prompt";
import { isGuidedEditResult } from "../lib/prompts/guided_edit_prompt";
import type { GuardValidations } from "../lib/types";
import { processTextWithCodeBlock, stripWrappedCharacter } from "./util";
export function parseChatAttempt<T>(attempt: string): { supportingText: string, message: T } {
const aiRefusalError = /(^i\'m sorry)|(?:ai(?:\s|-)?language(?:\s|-)?model|i(?:'?m| am))(?:[^.]*?)(?:can(?:'?t| not)|unable to)(?:[^.]*?)(?:perform|do|create|provide)/i;
if (aiRefusalError.test(attempt)) {
throw new Error('AI Refusal');
}
const isAbstractWrap = attempt.includes('&&&') && attempt.includes('@@@');
const isBacktickWrap = attempt.includes('```');
if (isAbstractWrap || isBacktickWrap) {
let innerBlockText = '';
let supportingText = '';
if (isBacktickWrap) {
const processedText = processTextWithCodeBlock(attempt);
innerBlockText = processedText.codeBlock;
supportingText = processedText.supportingText;
} else {
const outerBlockStart = attempt.indexOf('&&&') + 3;
const outerBlockEnd = attempt.lastIndexOf('&&&');
const pretextEnd = attempt.indexOf('@@@');
const innerBlockStart = pretextEnd + 3;
const innerBlockEnd = attempt.lastIndexOf('@@@');
const postTextStart = innerBlockEnd + 3;
innerBlockText = attempt.slice(innerBlockStart, innerBlockEnd);
const pretext = attempt.slice(outerBlockStart, pretextEnd);
const posttext = attempt.slice(postTextStart, outerBlockEnd);
supportingText = pretext + '\n' + posttext;
console.log({
ABSTRACTMATCHFOUND: true,
outerBlockStart,
outerBlockEnd,
pretextEnd,
innerBlockStart,
innerBlockEnd,
postTextStart
});
}
console.log({ supportingText, innerBlockText })
if (!innerBlockText.length) {
throw new Error('cannot parse Block structure is not valid.');
}
try {
if (innerBlockText.startsWith('{') || innerBlockText.startsWith('[')) {
JSON.parse(innerBlockText);
}
} catch (error) {
const err = error as Error;
throw new Error('cannot parse json.' + err.message)
}
console.log("Validating innerblocktext : ", innerBlockText)
const result = validateTypedResponse<T>(innerBlockText);
return { message: result, supportingText };
}
attempt | = stripWrappedCharacter(attempt); |
console.log("Parsing a basic attempt: ", attempt);
const result = validateTypedResponse<T>(attempt);
return { message: result, supportingText: '' };
}
export let responseValidators = [
isConvertPurposeResult,
isFileEditorResult,
isGuidedEditResult,
isCreateTypeResponse,
isCreateApiResult,
isCreateApiBackendResult,
isGeneralComponentResponse
];
export function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void {
responseValidators = responseValidators.concat(validators);
}
export function validateTypedResponse<T>(response: string): T {
if (!response) {
throw new Error('empty response');
}
try {
let body: GuardValidations = response;
try {
body = JSON.parse(response);
} catch (error) {}
for (const tg of responseValidators) {
if (body && tg(body)) {
return body as T;
}
console.log('Guard function:', tg.name, 'Result:', tg(body));
}
} catch (error) { }
throw new Error('bad chat format');
} | src/server/parser.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 49.976303310503454
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " return await resolveAttempt(responseTry, retries) as UseAIResponses<T>;\n } catch (error) {\n const err = error as Error;\n aiResponse.successful = false;\n logAiResult({ ...aiResponse, prompts, message: err.message + ' ' + err.stack, model: builtRequest.model });\n throw new Error('General use AI failure!\\nStack: ' + err.stack);\n }\n}",
"score": 49.73691586691361
},
{
"filename": "src/server/git/check_git_cli.ts",
"retrieved_chunk": " } catch (error) {\n const err = error as Error;\n console.error(\"Error:\", err.message);\n return false;\n }\n}\nexport function gitCheck() {\n if (!checkGitCli()) throw new Error('github cli is required to be installed and configured in order to use this flow');\n}",
"score": 46.5276099068231
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " aiResponse.failures.push(imparsable);\n throw new Error(imparsable);\n }\n return await resolveAttempt(repeatedAttempt, retriesRemaining - 1);\n }\n const resolveIssue = 'Critical chat parse error or could not resolve a valid response after ' + retries + ' attempts. ' + (err.message ? 'Parsing error: ' + err.message : '');\n aiResponse.failures.push(resolveIssue);\n throw new Error(resolveIssue);\n }\n }",
"score": 45.081531055503056
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " responseMessage = 'guided edit produced no modifications for ' + fileName;\n }\n await goHome();\n return responseMessage;\n }\n } catch (error) {\n await goHome();\n const err = error as Error;\n return err.message + '\\n\\n' + err.stack;\n }",
"score": 41.402768351150726
}
] | typescript | = stripWrappedCharacter(attempt); |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {});
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
| const stKey = statementKey as GuidedEditKeys; |
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " if (!originalFileContents) throw 'File not found.';\n const lined = originalFileContents.split('\\n').map((l, i) => `${i + 1}. ${l}`);\n console.log({ lined, fileName, suggestedEdits });\n const response = await useAi<FileEditorResponse>(IPrompts.FILE_EDITOR, fileName, suggestedEdits.join(' '), lined.join('\\n'));\n console.log({ EDITOR_FINISHED: response.message });\n const editedLines: Record<string, string> = response.message.split('\\n').reduce((m, d) => {\n const match = d.match(/^\\d+. /);\n if (match) {\n console.log({ match })\n return ({",
"score": 33.937429802513165
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;\nexport type GuidedEditResponse = Record<GuidedEditKeys, string>[];\nexport function isGuidedEditResult(obj: GuardValidations): boolean {\n return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {\n const guidedEditKey = new RegExp(`^${test}_\\\\d+$`);\n return hasSimilarKey(item, guidedEditKey)\n }));\n}",
"score": 30.069928913889136
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": " const { message } = res;\n Object.assign(metrics, { data: { message } });\n }\n if (isModerationResponse(res)) {\n const { flagged } = res;\n Object.assign(metrics, { data: { flagged } });\n }\n Object.assign(metrics, { type: metric.promptType, template: metric.promptTemplate, rawResponses, failures });\n fs.appendFileSync(config.ai.logFile, `${JSON.stringify(metrics)}\\n`);\n}",
"score": 29.18185547391717
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\\$\\{prompt${i + 1}\\}`]: t }), {});\n const promptTemplate = aiPrompts[promptType];\n if (!promptTemplate) throw new Error('invalid prompt type');\n const originalPromptTemplate = JSON.stringify(promptTemplate);\n const completionStringOrMessageHistory = promptTemplate;\n if ('string' === typeof completionStringOrMessageHistory) {\n let completionString = String(completionStringOrMessageHistory);\n for (const token in promptTokens) {\n completionString = completionString.replaceAll(token, promptTokens[token]);\n }",
"score": 28.81100278776234
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 28.236045859145026
}
] | typescript | const stKey = statementKey as GuidedEditKeys; |
#!/usr/bin/env node
import yargs from 'yargs/yargs';
import { config, saveConfig, getConfigValue, checkConfigExists } from './config';
import * as spells from './spells';
import { IPrompts } from '../lib/prompts';
const parser = yargs(process.argv.slice(2))
// .options({
// 'config': {
// alias: 'c',
// describe: 'Path to the configuration file',
// default: 'config.json',
// type: 'string',
// },
// 'verbose': {
// alias: 'v',
// describe: 'Display verbose output',
// default: false,
// type: 'boolean',
// },
// })
.command(
'set [key] [value]',
'Set a configuration value',
(yargs) => {
return yargs.positional('key', {
describe: 'Configuration key to set',
type: 'string',
}).positional('value', {
describe: 'Value to set for the configuration key',
type: 'string',
});
},
(argv) => {
checkConfigExists();
if (!argv.key) throw new Error('key required');
const keys = argv.key.split('.');
const [current, lastKey] = getConfigValue(config, keys);
current[lastKey] = argv.value || '';
saveConfig();
}
)
.command(
'use-ai [promptType] [prompts...]',
'Use AI with the specified prompts',
(yargs) => {
return yargs
.positional('promptType', {
describe: 'The type of prompt to use',
default: undefined,
type: 'string',
})
.positional('prompts', {
describe: 'Prompts',
demandOption: true,
type: 'string',
nargs: 1,
array: true,
});
},
async (argv) => {
await spells.useAi(argv.promptType as IPrompts | undefined, ...argv.prompts)
.then( | (result) => console.log(result))
.catch((error) => console.error(error)); |
}
)
.command(
'guided-edit [fileNameWithInstructions] [optionalName]',
'Run guided edit',
(yargs) => {
return yargs
.positional('fileNameWithInstructions', {
describe: 'File name with instructions',
type: 'string',
demandOption: true
})
.positional('optionalName', {
describe: 'Optional name',
type: 'string',
})
.options({
'commit': {
type: 'boolean',
description: 'Will commit edits to the generated branch',
default: true,
},
'pull-request': {
type: 'boolean',
description: 'Will create and add to 1 pull request per generated branch',
default: true,
},
});
},
async (argv) => {
await spells.guidedEdit(argv.fileNameWithInstructions, argv.optionalName)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'file-editor <fileName> [instructions...]',
'Edit any file',
(yargs) => {
return yargs
.positional('fileName', {
describe: 'File Name',
type: 'string',
demandOption: true
})
.positional('instructions', {
describe: 'File name with instructions',
type: 'string',
array: true,
demandOption: true
});
},
async (argv) => {
await spells.fileEditor(argv.fileName, ...argv.instructions)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-component [description]',
'Create a component',
(yargs) => {
return yargs
.positional('description', {
describe: 'Component description',
demandOption: true,
type: 'string',
});
},
async (argv) => {
await spells.createComponent(argv.description)
.then((result) => console.log(result))
.catch((error) => console.error(error));
}
)
.command(
'create-api [typeName]',
'Create an API',
(yargs) => {
return yargs
.positional('typeName', {
describe: 'API type name',
demandOption: true,
type: 'string',
});
},
async (argv) => {
const generatedType = await spells.createType(argv.typeName)
await spells.createApi(argv.typeName, generatedType)
.then((result) => console.log(result))
.catch((error) => console.error(error));
await spells.createApiBackend(argv.typeName, generatedType);
}
)
.demandCommand(1, 'You need at least one command before moving on')
.help()
.alias('h', 'help')
.strict();
(async () => {
await parser.argv;
})(); | src/server/cli.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " JSON.parse(innerBlockText);\n }\n } catch (error) {\n const err = error as Error;\n throw new Error('cannot parse json.' + err.message)\n }\n console.log(\"Validating innerblocktext : \", innerBlockText)\n const result = validateTypedResponse<T>(innerBlockText);\n return { message: result, supportingText };\n }",
"score": 35.009438805533705
},
{
"filename": "src/server/spells/create_api_backend_spell.ts",
"retrieved_chunk": " }\n }\n try {\n const generatedApiBackend = await useAi<CreateApiBackendResult>(IPrompts.CREATE_API_BACKEND, generatedType + ' ' + apiEndpoints.join(' '))\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`;\n sourceFile.insertText(sourceFile.getEnd(), `${comment}${generatedApiBackend.message}\\n\\n`);\n sourceFile.fixMissingImports();\n await project.save();\n } catch (error) {\n console.error(error);",
"score": 30.35171753680551
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " return JSON.parse(result.toString());\n } catch (error) {\n console.error('Error parsing JSON from extraction script:', error);\n return [];\n }\n}\nexport function copyContentsToDocker(fileName: string, content: string) {\n const tempContentPath = getTempFilePath(fileName, content);\n execSync(`docker cp ${tempContentPath} ${containerName}:/app/${fileName}`)\n}",
"score": 29.85679145362691
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 26.40839086134223
},
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " await git.checkoutBranch(generatedBranch, config.git.source);\n await git.push(config.git.remote, generatedBranch, ['--set-upstream', generatedBranch])\n } catch (error) {\n const err = error as Error;\n if (err.message.includes('A branch named') && err.message.includes('already exists')) {\n console.log('Checking out existing generated branch ', generatedBranch);\n await git.checkout(generatedBranch);\n console.log('Pulling generated branch.');\n await git.pull(config.git.remote, generatedBranch);\n }",
"score": 26.23047404970567
}
] | typescript | (result) => console.log(result))
.catch((error) => console.error(error)); |
// config.ts
import fs from 'fs';
import path from 'path';
import type { Config as RootConfig, ConfigPropTypes } from '../lib/types';
import { isConfigNestedObject } from '../lib/util';
export const isCliRunning = process.argv[1].includes('bin/src/cli.js');
export const isCalledWithNpx = process.env.npm_execpath && /npx(-cli\.js)?$/.test(process.env.npm_execpath);
const normalPath = path.join(__dirname, `${isCliRunning ? '../..' : isCalledWithNpx ? process.cwd() : '..'}/config.json`)
const npxPath = path.join(process.cwd(), 'config.json')
export const configFilePath = isCalledWithNpx ? npxPath : normalPath;
// Default configuration values
export const defaultConfig = {
ai: { retries: '3', logFile: 'results.json', chatModel: 'gpt-3.5-turbo', completionModel: 'curie' },
ts: { configPath: '', typeDir: '', compDir: '' },
git: { rootPath: '', source: 'main', remote: 'origin' },
user: { name: 'wizapp' }
};
type Config = RootConfig<typeof defaultConfig>;
// Load existing configuration or create a new file with default values
export let config = defaultConfig;
export function checkConfigExists() {
if (fs.existsSync(configFilePath)) {
const rawData = fs.readFileSync(configFilePath);
config = JSON.parse(rawData.toString());
} else {
fs.writeFileSync(configFilePath, JSON.stringify(defaultConfig, null, 2));
config = defaultConfig;
}
}
checkConfigExists();
// Function to save the configuration
export function saveConfig(): void {
fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
}
export function setConfig(newConfig: Config): void {
config = newConfig;
}
export function getConfig(): Config {
return config;
}
export function getConfigFromPath(configPath: string): Config {
let optionalConfig: Config;
try {
const configText = fs.readFileSync(configPath, 'utf-8');
optionalConfig = JSON.parse(configText) as Config;
} catch (error) {
optionalConfig = defaultConfig;
}
return optionalConfig;
}
// Helper function
export function getConfigValue(config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] {
let current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config;
for (let i = 0; i < keys.length - 1; i++) {
| if (!isConfigNestedObject(current[keys[i]])) { |
throw new Error('invalid config key');
}
current = current[keys[i]] as Record<string, ConfigPropTypes>;
}
return [current, keys[keys.length - 1]];
} | src/server/config.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/types.ts",
"retrieved_chunk": "export type ConfigPropTypes = string;\nexport type Config<T = Record<string, Record<string, ConfigPropTypes>>> = T;\nexport type CurrentType = ConfigPropTypes | Config;\nexport type GuardValidations = Record<string, unknown> | Record<string, unknown>[] | string\nexport type OpenAIResults = {\n model?: string;\n timestamp: Date;\n prompts?: string[];\n promptType: string;\n promptTemplate: string | undefined;",
"score": 64.95393439210098
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 46.224489361244466
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " parsedStatementText = parent.getText();\n }\n return parsedStatementText;\n}\nconst ignoredStatements = [SyntaxKind.TryStatement]\nfunction walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {\n const statementName = `statement_${i}`;\n if (child instanceof FunctionDeclaration) {\n child.getStatements().forEach((descendant, index) => {\n walkNode(descendant, index + i, parsedStatements, originalStatements);",
"score": 45.39481034579648
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\\$\\{prompt${i + 1}\\}`]: t }), {});\n const promptTemplate = aiPrompts[promptType];\n if (!promptTemplate) throw new Error('invalid prompt type');\n const originalPromptTemplate = JSON.stringify(promptTemplate);\n const completionStringOrMessageHistory = promptTemplate;\n if ('string' === typeof completionStringOrMessageHistory) {\n let completionString = String(completionStringOrMessageHistory);\n for (const token in promptTokens) {\n completionString = completionString.replaceAll(token, promptTokens[token]);\n }",
"score": 43.78976441181314
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " });\n },\n (argv) => {\n checkConfigExists();\n if (!argv.key) throw new Error('key required');\n const keys = argv.key.split('.');\n const [current, lastKey] = getConfigValue(config, keys);\n current[lastKey] = argv.value || '';\n saveConfig();\n }",
"score": 41.16614502955367
}
] | typescript | if (!isConfigNestedObject(current[keys[i]])) { |
import fs from 'fs';
import path from "path";
import { sync } from 'fast-glob';
import { isCalledWithNpx, isCliRunning } from "./config";
import languages from "../lib/languages";
import type { OpenAIRequestShapes } from './types';
import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from 'openai';
const langValues = Object.values(languages);
export const codeGPTPrecursor = 'You are BacktickGPT, providing only typescript code responses wrapped with 3 backticks before and after.';
export function deepClone<T>(obj: T): T {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map((item) => deepClone(item) as T) as unknown as T;
}
const result: Record<string, unknown> = {};
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = deepClone((obj as Record<string, unknown>)[key]);
}
}
return result as T;
}
export const isValidName = (name: string): boolean => {
const regex = /^I[A-Z][a-zA-Z]*$/;
return regex.test(name);
};
export const toSnakeCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);
};
export const toTitleCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
};
export function extractCodeBlock(inputString: string, delimeter: string = '```', languages: string[] = ['typescript', 'json', 'jsx', 'tsx']) {
const langStartTag = (language: string) => language ? `${delimeter}${language}` : delimeter;
for (const language of languages) {
const startTag = langStartTag(language);
if (inputString.includes(startTag)) {
return {
codeBlock: inputString.split(startTag)[1].split(delimeter)[0],
index: inputString.indexOf(startTag) + startTag.length,
};
}
}
if (inputString.includes(delimeter)) {
const index = inputString.indexOf(delimeter) + delimeter.length;
return {
codeBlock: inputString.split(delimeter)[1],
index,
};
}
return {
codeBlock: inputString,
index: 0,
};
};
export function extractCodeBlockPre(inputString: string, index: number): string {
return inputString.substring(0, index)?.trim() || '';
}
export function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {
return inputString.substring(index).split(delimeter)[1]?.trim() || '';
}
export function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {
const { codeBlock, index } = extractCodeBlock(inputString);
const preText = extractCodeBlockPre(inputString, index);
const postText = extractCodeBlockPost(inputString, index);
return {
codeBlock,
supportingText: preText + ' ' + postText,
};
}
export function stripWrappedCharacter(inputString: string, wrappedCharacters: string[] = ['"', "'"]): string {
for (const char of wrappedCharacters) {
if (inputString.startsWith(char)) inputString = inputString.slice(1);
if (inputString.endsWith(char)) inputString = inputString.substring(0, inputString.length - 1);
}
return inputString;
}
export function sanitizeName(input: string): string {
// Trim whitespaces and replace consecutive spaces with a single dash
const trimmed = input.trim();
// Remove invalid characters: ~ ^ : ? * [ ] @ { } \ /
const sanitized = trimmed.replace(/[~^:?"*\[\]@{}\\/]+/g, '');
// Limit branch name length to 100 characters
const maxLength = 100;
const shortened = sanitized.slice(0, maxLength);
// Remove leading and trailing period (.)
const noLeadingTrailingPeriods = shortened.replace(/(^\.+|\.+$)/g, '');
// Remove leading and trailing forward slash (-)
const result = noLeadingTrailingPeriods.replace(/(^-+|-+$)/g, '');
return result;
}
export function ensureKeysAreQuoted(jsonString: string): string {
const unquotedKeysRegex = /([{,]\s*)(\w+)\s*:/g;
function quoteKeys(match: unknown, prefix: string, key: string) {
return `${prefix}"${key}":`;
}
return jsonString.replace(unquotedKeysRegex, quoteKeys);
}
export function typeDefinitionToSentence(typeDefinition: string): string {
const typeNameMatch = typeDefinition.match(/export type (\w+)/);
if (!typeNameMatch) {
return 'Invalid type definition provided.';
}
const typeName = typeNameMatch[1];
const properties = [];
const propertyRegex = /(\w+)\s*:\s*([^;]+);/g;
let match;
while ((match = propertyRegex.exec(typeDefinition)) !== null) {
properties.push({ key: match[1], type: match[2].trim().replace(/\s+/g, ' ') });
}
if (properties.length > 0) {
const propertiesDescription = properties
.map((property) => `${property.key} as a ${property.type}`)
.join(', ');
return `${typeName} defines ${propertiesDescription}.`;
} else {
const recordMatch = typeDefinition.match(/Record<(.+),\s*(.+)>/);
if (recordMatch) {
return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;
}
}
return 'Unable to parse the type definition.';
}
export function getDirPathOf(filePath: string) {
return path.dirname(filePath)
}
export function generateTempFilePath(dir: string, name: string) {
return path.join(dir, `${name}-${Date.now()}.json`)
}
export function getRootDir() {
return isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../');
}
export function getPathOf(name: string, baseDir?: string): string {
return path.join(baseDir || getRootDir(), name);
}
export function getFileParser(fileName: string) {
const extension = path.extname(fileName);
| const parser = langValues.find(l => l.fileExtension.includes(extension)); |
if (!parser) throw 'That parser is undefined!';
return parser.parserName;
}
export function getFileFromDir(file: string, dir: string = __dirname) {
const files = fs.readdirSync(dir);
const fileName = files.find(f => f.startsWith(file));
if (!fileName) throw 'File not found.';
return fs.readFileSync(path.join(dir, fileName), { encoding: 'utf-8' })
}
export function getTargetFile(targetFile: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string | null {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return files.length > 0 ? fileContent : null;
}
export function saveTargetFile(targetFile: string, contents: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.writeFileSync(files[0], contents, { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return 'file saved';
}
const excludeDirectories = [
'node_modules',
'vendor',
'dist',
'build',
'.git',
'.svn',
// add other directories to exclude
];
export function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest {
return 'messages' in obj;
}
export function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {
return 'prompt' in obj;
}
export function isModerationRequest(obj: OpenAIRequestShapes): obj is CreateModerationRequest {
return 'input' in obj;
} | src/server/util.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/tree/getStatements.ts",
"retrieved_chunk": "// import TreeSitter, { SyntaxNode, Tree } from 'tree-sitter';\n// import path from 'path';\n// import languages from '../languages';\n// import { getFileFromDir } from '../util';\n// import { LinearizedStatement } from '../types';\n// import { getGrammarPatterns } from './ast';\n// const langValues = Object.values(languages);\n// export async function getStatements(fileName: string): Promise<LinearizedStatement[]> {\n// const extension = path.extname(fileName).slice(1);\n// const langParser = langValues.find(lang => lang.fileExtension.includes(extension));",
"score": 56.55715898806484
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// config.ts\nimport fs from 'fs';\nimport path from 'path';\nimport type { Config as RootConfig, ConfigPropTypes } from '../lib/types';\nimport { isConfigNestedObject } from '../lib/util';\nexport const isCliRunning = process.argv[1].includes('bin/src/cli.js');\nexport const isCalledWithNpx = process.env.npm_execpath && /npx(-cli\\.js)?$/.test(process.env.npm_execpath);\nconst normalPath = path.join(__dirname, `${isCliRunning ? '../..' : isCalledWithNpx ? process.cwd() : '..'}/config.json`)\nconst npxPath = path.join(process.cwd(), 'config.json')\nexport const configFilePath = isCalledWithNpx ? npxPath : normalPath;",
"score": 53.36632821555401
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " const tempFilePath = path.join(tempDir, fileName);\n fs.writeFileSync(tempFilePath, content);\n return tempFilePath;\n}\nfunction containerExists(): boolean {\n try {\n execSync(`docker inspect ${containerName}`);\n return true;\n } catch (error) {\n return false;",
"score": 32.13939113248409
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": "export function processFile(fileName: string) {\n activeTasks++;\n buildAndCopyFile(fileName);\n runExtractionScript();\n const localModsPath = 'path/to/your/local_modifications_file';\n copyModifications(localModsPath);\n runModificationScript();\n copyModifiedFileToLocal(fileName);\n activeTasks--;\n if (!activeTasks) {",
"score": 30.45844111180501
},
{
"filename": "src/tree/modifier.ts",
"retrieved_chunk": "export function createModificationsFunction(): (statement: Statements) => Statements | null {\n const rules = JSON.parse(fs.readFileSync(path.join(__dirname, '../files/mods'), { encoding: 'utf-8' }).toString()) as ModificationRules[];\n return (statement: Statements) => {\n const rule = rules.find((r) => r.type === statement.type);\n if (!rule) {\n return statement;\n }\n switch (rule.action) {\n case 'add':\n return {",
"score": 30.27232818780663
}
] | typescript | const parser = langValues.find(l => l.fileExtension.includes(extension)); |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory = deepClone(completionStringOrMessageHistory);
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if (isChatRequest(request)) {
const chatResponse = await openai. | createChatCompletion(request, openAIRequestOptions); |
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
} else if (isCompletionRequest(request)) {
const completionResponse = await openai.createCompletion(request, openAIRequestOptions);
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
} else if (isModerationRequest(request)) {
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " 'commit': {\n type: 'boolean',\n description: 'Will commit edits to the generated branch',\n default: true,\n },\n 'pull-request': {\n type: 'boolean',\n description: 'Will create and add to 1 pull request per generated branch',\n default: true,\n },",
"score": 30.701436641996246
},
{
"filename": "src/server/index.ts",
"retrieved_chunk": "export * from './spells';\nexport * from './parser';\nexport * from './util';\nexport * from './request';\nexport * from './stats';\nexport type {\n OpenAIRequestShapes\n} from './types';",
"score": 28.54910164271678
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": "import { parseChatAttempt } from '../parser';\nimport { IPrompts } from '../../lib/prompts';\nimport { buildOpenAIRequest, performRequest } from '../request';\nimport { logAiResult } from '../stats';\nimport { getConfig } from '../config';\nimport type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';\nimport { isCompletionRequest } from '../util';\nexport async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {\n const config = getConfig();\n const retries = parseInt(config.ai.retries, 10);",
"score": 26.773026155917158
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const responseTry = await performRequest(builtRequest);\n aiResponse.rawResponses.push(responseTry);\n if ('undefined' === typeof responseTry) {\n const noChoices = 'Open AI returned no choices.'\n aiResponse.failures.push(noChoices);\n throw new Error(noChoices);\n }\n if ('boolean' === typeof responseTry) {\n const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };\n console.log('MODERATION RESPONSE :==: ', moderationResponse)",
"score": 22.829457403805296
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 21.590303391965346
}
] | typescript | createChatCompletion(request, openAIRequestOptions); |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory | = deepClone(completionStringOrMessageHistory); |
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if (isChatRequest(request)) {
const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
} else if (isCompletionRequest(request)) {
const completionResponse = await openai.createCompletion(request, openAIRequestOptions);
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
} else if (isModerationRequest(request)) {
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/util.ts",
"retrieved_chunk": " if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n if (Array.isArray(obj)) {\n return obj.map((item) => deepClone(item) as T) as unknown as T;\n }\n const result: Record<string, unknown> = {};\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = deepClone((obj as Record<string, unknown>)[key]);",
"score": 16.579716799640103
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " )\n .command(\n 'use-ai [promptType] [prompts...]',\n 'Use AI with the specified prompts',\n (yargs) => {\n return yargs\n .positional('promptType', {\n describe: 'The type of prompt to use',\n default: undefined,\n type: 'string',",
"score": 9.864342881927595
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;\nexport type GuidedEditResponse = Record<GuidedEditKeys, string>[];\nexport function isGuidedEditResult(obj: GuardValidations): boolean {\n return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {\n const guidedEditKey = new RegExp(`^${test}_\\\\d+$`);\n return hasSimilarKey(item, guidedEditKey)\n }));\n}",
"score": 9.813894677130078
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Default configuration values\nexport const defaultConfig = {\n ai: { retries: '3', logFile: 'results.json', chatModel: 'gpt-3.5-turbo', completionModel: 'curie' },\n ts: { configPath: '', typeDir: '', compDir: '' },\n git: { rootPath: '', source: 'main', remote: 'origin' },\n user: { name: 'wizapp' }\n};\ntype Config = RootConfig<typeof defaultConfig>;\n// Load existing configuration or create a new file with default values\nexport let config = defaultConfig;",
"score": 9.624297275476216
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "export function isChatResponse<T>(obj: GuardValidations): obj is ChatResponse<T> {\n return 'object' === typeof obj && 'message' in obj && Array.isArray(obj.message);\n}\nexport function isCompletionResponse(obj: GuardValidations): obj is CompletionResponse {\n return 'object' === typeof obj && 'message' in obj && 'string' === typeof obj.message;\n}\nexport function isModerationResponse(obj: GuardValidations): obj is ModerationResponse {\n return 'object' === typeof obj && 'input' in obj;\n}",
"score": 8.699351957002488
}
] | typescript | = deepClone(completionStringOrMessageHistory); |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory = deepClone(completionStringOrMessageHistory);
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if (isChatRequest(request)) {
const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
| } else if (isCompletionRequest(request)) { |
const completionResponse = await openai.createCompletion(request, openAIRequestOptions);
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
} else if (isModerationRequest(request)) {
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });\n console.log('CHAT RESPONSE :==: ', chatResponse)\n return chatResponse;\n } catch (error) {\n const err = error as Error;\n if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {\n const repeatedAttempt = await performRequest(builtRequest);\n aiResponse.rawResponses.push(repeatedAttempt);\n if ('string' !== typeof repeatedAttempt) {\n const imparsable = 'Received imparsable resolution during retry.';",
"score": 47.76402306152676
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const responseTry = await performRequest(builtRequest);\n aiResponse.rawResponses.push(responseTry);\n if ('undefined' === typeof responseTry) {\n const noChoices = 'Open AI returned no choices.'\n aiResponse.failures.push(noChoices);\n throw new Error(noChoices);\n }\n if ('boolean' === typeof responseTry) {\n const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };\n console.log('MODERATION RESPONSE :==: ', moderationResponse)",
"score": 38.290336080419884
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " 'commit': {\n type: 'boolean',\n description: 'Will commit edits to the generated branch',\n default: true,\n },\n 'pull-request': {\n type: 'boolean',\n description: 'Will create and add to 1 pull request per generated branch',\n default: true,\n },",
"score": 37.409499404945386
},
{
"filename": "src/server/index.ts",
"retrieved_chunk": "export * from './spells';\nexport * from './parser';\nexport * from './util';\nexport * from './request';\nexport * from './stats';\nexport type {\n OpenAIRequestShapes\n} from './types';",
"score": 34.172277978498535
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": "import { parseChatAttempt } from '../parser';\nimport { IPrompts } from '../../lib/prompts';\nimport { buildOpenAIRequest, performRequest } from '../request';\nimport { logAiResult } from '../stats';\nimport { getConfig } from '../config';\nimport type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';\nimport { isCompletionRequest } from '../util';\nexport async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {\n const config = getConfig();\n const retries = parseInt(config.ai.retries, 10);",
"score": 33.991333152106904
}
] | typescript | } else if (isCompletionRequest(request)) { |
import { CreateModerationRequest, OpenAIApi } from "openai";
import { aiPrompts, IPrompts } from "../lib/prompts";
import type { OpenAIRequestShapes } from "./types";
import { deepClone, isChatRequest, isCompletionRequest, isModerationRequest } from "./util";
import { getConfig } from "./config";
const openai = new OpenAIApi();
export const openAIRequestOptions = {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.OPENAI_API_KEY as string}`
}
};
export function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {
const config = getConfig();
if (!promptType) {
const moderationRequest: CreateModerationRequest = {
input: prompts[0]
}
return [moderationRequest];
}
const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\$\{prompt${i + 1}\}`]: t }), {});
const promptTemplate = aiPrompts[promptType];
if (!promptTemplate) throw new Error('invalid prompt type');
const originalPromptTemplate = JSON.stringify(promptTemplate);
const completionStringOrMessageHistory = promptTemplate;
if ('string' === typeof completionStringOrMessageHistory) {
let completionString = String(completionStringOrMessageHistory);
for (const token in promptTokens) {
completionString = completionString.replaceAll(token, promptTokens[token]);
}
const completionRequest = {
model: config.ai.completionModel,
prompt: completionString
};
return [completionRequest, originalPromptTemplate]
}
if (Array.isArray(completionStringOrMessageHistory)) {
const messageHistory = | deepClone(completionStringOrMessageHistory); |
for (let item of messageHistory) {
if (item.content.includes('${') && item.content.includes('}')) {
for (const token in promptTokens) {
item.content = item.content.replaceAll(token, promptTokens[token]);
}
}
}
const chatRequest = {
model: config.ai.chatModel,
messages: messageHistory
};
return [chatRequest, originalPromptTemplate]
}
throw new Error('invalid prompting procedure');
}
export async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {
console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))
if (isChatRequest(request)) {
const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);
console.log({ RAW_CHAT: chatResponse.data.choices[0] });
return chatResponse.data.choices[0]?.message?.content.trim();
} else if (isCompletionRequest(request)) {
const completionResponse = await openai.createCompletion(request, openAIRequestOptions);
console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });
return completionResponse.data.choices[0].text?.trim();
} else if (isModerationRequest(request)) {
const moderationResponse = await openai.createModeration(request, openAIRequestOptions);
console.log({ RAW_MODERATION: moderationResponse.data.results[0] });
return moderationResponse.data.results[0]?.flagged;
}
} | src/server/request.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/util.ts",
"retrieved_chunk": " if (obj === null || typeof obj !== 'object') {\n return obj;\n }\n if (Array.isArray(obj)) {\n return obj.map((item) => deepClone(item) as T) as unknown as T;\n }\n const result: Record<string, unknown> = {};\n for (const key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n result[key] = deepClone((obj as Record<string, unknown>)[key]);",
"score": 16.579716799640103
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " )\n .command(\n 'use-ai [promptType] [prompts...]',\n 'Use AI with the specified prompts',\n (yargs) => {\n return yargs\n .positional('promptType', {\n describe: 'The type of prompt to use',\n default: undefined,\n type: 'string',",
"score": 9.864342881927595
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;\nexport type GuidedEditResponse = Record<GuidedEditKeys, string>[];\nexport function isGuidedEditResult(obj: GuardValidations): boolean {\n return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {\n const guidedEditKey = new RegExp(`^${test}_\\\\d+$`);\n return hasSimilarKey(item, guidedEditKey)\n }));\n}",
"score": 9.813894677130078
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Default configuration values\nexport const defaultConfig = {\n ai: { retries: '3', logFile: 'results.json', chatModel: 'gpt-3.5-turbo', completionModel: 'curie' },\n ts: { configPath: '', typeDir: '', compDir: '' },\n git: { rootPath: '', source: 'main', remote: 'origin' },\n user: { name: 'wizapp' }\n};\ntype Config = RootConfig<typeof defaultConfig>;\n// Load existing configuration or create a new file with default values\nexport let config = defaultConfig;",
"score": 9.624297275476216
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "export function isChatResponse<T>(obj: GuardValidations): obj is ChatResponse<T> {\n return 'object' === typeof obj && 'message' in obj && Array.isArray(obj.message);\n}\nexport function isCompletionResponse(obj: GuardValidations): obj is CompletionResponse {\n return 'object' === typeof obj && 'message' in obj && 'string' === typeof obj.message;\n}\nexport function isModerationResponse(obj: GuardValidations): obj is ModerationResponse {\n return 'object' === typeof obj && 'input' in obj;\n}",
"score": 8.699351957002488
}
] | typescript | deepClone(completionStringOrMessageHistory); |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
const generatedStatements = res.message.reduce((m, d) => ({ ...m, ...d }), {});
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
| await goHome(); |
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " const git = simpleGit(config.git.rootPath);\n const generatedBranch = sanitizeName(`gen/${name}`);\n console.log('Prepare branch main checkout.');\n await git.checkout(config.git.source);\n console.log('Pulling main.');\n await git.pull(config.git.remote, config.git.source);\n console.log('Fetching.');\n await git.fetch('all');\n try {\n console.log('Creating a new branch for ', generatedBranch);",
"score": 34.280471294259456
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " await spells.useAi(argv.promptType as IPrompts | undefined, ...argv.prompts)\n .then((result) => console.log(result))\n .catch((error) => console.error(error));\n }\n )\n .command(\n 'guided-edit [fileNameWithInstructions] [optionalName]',\n 'Run guided edit',\n (yargs) => {\n return yargs",
"score": 33.247837457274
},
{
"filename": "src/server/git/prepare_branch.ts",
"retrieved_chunk": " await git.checkoutBranch(generatedBranch, config.git.source);\n await git.push(config.git.remote, generatedBranch, ['--set-upstream', generatedBranch])\n } catch (error) {\n const err = error as Error;\n if (err.message.includes('A branch named') && err.message.includes('already exists')) {\n console.log('Checking out existing generated branch ', generatedBranch);\n await git.checkout(generatedBranch);\n console.log('Pulling generated branch.');\n await git.pull(config.git.remote, generatedBranch);\n }",
"score": 32.44121921963034
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " const edit = key && editedLines[key as keyof typeof editedLines];\n if (edit) {\n return edit.replace(regex, ''); \n }\n return l.slice(match?match[0].length:0);\n }).filter(l => l?.length > 0).join('\\n');\n console.log({ lined, editedLines, editedFile, editNum: Object.keys(editedLines).length });\n const saved = saveTargetFile(fileName, editedFile);\n return saved;\n}",
"score": 26.893702263339403
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " throw new Error(\"Invalid name format\");\n }\n return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);\n};\nexport const toTitleCase = (name: string): string => {\n if (!isValidName(name)) {\n throw new Error(\"Invalid name format\");\n }\n return name.substr(1).replace(/([A-Z])/g, \" $1\").replace(/^./, (str) => str.toUpperCase());\n};",
"score": 23.06506251293993
}
] | typescript | await goHome(); |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
| const actionText = await makeDecision(events); |
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 45.107259816256956
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 34.57120116980217
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 32.24619844725737
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.agentId,\n nestedEvents.flat().join(\"\\n\\n\")\n ),\n };\n }\n private removeErrors(events: Event[]): Event[] {\n const cleaned: Event[] = [];\n for (let i = events.length - 1; i >= 0; i--) {\n const event = events[i];\n if (event.type === \"message\" && event.message.type === \"error\") {",
"score": 27.806081593196367
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const prevEvent = events[i - 1];\n // console.log(\"REMOVING\", JSON.stringify(prevEvent, null, 2));\n // console.log(\"REMOVING\", JSON.stringify(event, null, 2));\n if (prevEvent.type === \"decision\") {\n i--; // skip the previous action which generated the error\n } else {\n console.error(\"error event was not preceded by an action\");\n }\n continue;\n }",
"score": 26.716835234725245
}
] | typescript | const actionText = await makeDecision(events); |
import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';
import { useAi } from './use_ai_spell';
import { IPrompts } from '../../lib/prompts';
import { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';
import { getConfig } from '../config';
import { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';
function getStatementText(child: Node) {
let parsedStatementText = child.getText();
const parent = child.getParent();
if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {
parsedStatementText = parent.getText();
}
return parsedStatementText;
}
const ignoredStatements = [SyntaxKind.TryStatement]
function walkNode(child: Node, i: number, parsedStatements: Record<string, string>, originalStatements: Map<string, string>) {
const statementName = `statement_${i}`;
if (child instanceof FunctionDeclaration) {
child.getStatements().forEach((descendant, index) => {
walkNode(descendant, index + i, parsedStatements, originalStatements);
})
} else if (!ignoredStatements.includes(child.getKind())) {
parsedStatements[statementName] = getStatementText(child);
originalStatements.set(statementName, getStatementText(child));
}
}
export async function guidedEdit(fileParts: string, editingUser?: string): Promise<string> {
const config = getConfig();
if (!config.ts.configPath) {
throw new Error('Missing ts.configPath.')
}
const project = new Project({
tsConfigFilePath: config.ts.configPath
});
const [fileName, ...suggestedEdits] = fileParts.split(' ');
const suggestions = suggestedEdits.join(' ');
const generatedBranch = await prepareBranch(editingUser || config.user.name);
try {
const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];
if (sourceFile) {
if (sourceFile.getText().length > 10000) {
return 'the file is too large';
}
const originalStatements: Map<string, string> = new Map();
const parsedStatements: Record<string, string> = {};
sourceFile.getStatements().forEach((statement, index) => {
walkNode(statement, index, parsedStatements, originalStatements);
});
const res = await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements));
const generatedStatements = res. | message.reduce((m, d) => ({ ...m, ...d }), {}); |
let fileContent = sourceFile.getFullText();
let fileModified = false;
Object.keys(generatedStatements).forEach(statementKey => {
const stKey = statementKey as GuidedEditKeys;
if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {
fileContent += `\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;
fileModified = true;
} else if ([/^above_\d{1,2}$/, /^below_\d{1,2}$/].some(regex => regex.test(stKey))) {
const [direction, index] = stKey.split('_');
const adjacentStatement = originalStatements.get(`statement_${index}`);
if (adjacentStatement) {
let adjacentStart = fileContent.indexOf(adjacentStatement);
let adjacentEnd = adjacentStart + adjacentStatement.length;
if ('above' == direction) {
fileContent = fileContent.substring(0, adjacentStart) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentStart);
adjacentStart = fileContent.indexOf(adjacentStatement);
adjacentEnd = adjacentStart + adjacentStatement.length;
} else {
fileContent = fileContent.substring(0, adjacentEnd) + '\n' + generatedStatements[stKey] + fileContent.substring(adjacentEnd);
}
fileModified = true;
}
} else {
const originalStatement = originalStatements.get(stKey);
if (originalStatement) {
const originalIndex = fileContent.indexOf(originalStatement);
if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {
fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);
fileModified = true;
}
}
}
});
let responseMessage = '';
if (fileModified) {
// const projectDiffPath = path.resolve('~/code/project_diff');
// const apiPath = path.join(projectDiffPath, 'api');
// const tsConfigFilePath = path.join(apiPath, 'projectts.json');
// const tsConfigFile = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
// const configParseResult = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, apiPath)
// const testFile = ts.createSourceFile('temp.ts', fileContent, ts.ScriptTarget.ES2016, true);
// const testProgram = ts.createProgram([testFile.fileName], configParseResult.options)
// const diagnostics = ts.getPreEmitDiagnostics(testProgram);
// if (diagnostics.length > 0) {
// console.log('Diagnostic errors:');
// diagnostics.forEach(diagnostic => {
// const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
// console.log(`${diagnostic.file?.fileName} (${diagnostic.start}): ${message}`);
// })
// return 'you really did it now, no code, no show, no turkey';
// } else {
// console.log('Makin it pretty')
// try {
// fileContent = prettier.format(fileContent, {
// parser: 'typescript',
// tabWidth: 2,
// useTabs: false
// });
// } catch (error) { }
sourceFile.removeText();
sourceFile.insertText(0, fileContent);
sourceFile.saveSync();
await project.save();
const sourceFilePath = sourceFile.getFilePath().toString();
await pushCommit(sourceFilePath, generatedBranch, `${editingUser || config.user.name} - ${suggestions}`);
const prTitle = `${editingUser || config.user.name} edited ${fileName}: ${suggestions.replace(/[~^:?"*\[\]@{}\\/]+/g, '')}`.slice(0, 255);
const prBody = `GPT: ${res.supportingText || 'No supporting text found.'}`.replaceAll('"', '');
const prRes = await managePullRequest(generatedBranch, prTitle, prBody);
responseMessage = 'guided edit complete: ' + prRes;
} else {
responseMessage = 'guided edit produced no modifications for ' + fileName;
}
await goHome();
return responseMessage;
}
} catch (error) {
await goHome();
const err = error as Error;
return err.message + '\n\n' + err.stack;
}
return 'file not found: ' + fileName;
} | src/server/spells/guided_edit_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " if (!originalFileContents) throw 'File not found.';\n const lined = originalFileContents.split('\\n').map((l, i) => `${i + 1}. ${l}`);\n console.log({ lined, fileName, suggestedEdits });\n const response = await useAi<FileEditorResponse>(IPrompts.FILE_EDITOR, fileName, suggestedEdits.join(' '), lined.join('\\n'));\n console.log({ EDITOR_FINISHED: response.message });\n const editedLines: Record<string, string> = response.message.split('\\n').reduce((m, d) => {\n const match = d.match(/^\\d+. /);\n if (match) {\n console.log({ match })\n return ({",
"score": 36.10442455050781
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const promptTokens = prompts.reduce<Record<string, string>>((m, t, i) => ({ ...m, [`\\$\\{prompt${i + 1}\\}`]: t }), {});\n const promptTemplate = aiPrompts[promptType];\n if (!promptTemplate) throw new Error('invalid prompt type');\n const originalPromptTemplate = JSON.stringify(promptTemplate);\n const completionStringOrMessageHistory = promptTemplate;\n if ('string' === typeof completionStringOrMessageHistory) {\n let completionString = String(completionStringOrMessageHistory);\n for (const token in promptTokens) {\n completionString = completionString.replaceAll(token, promptTokens[token]);\n }",
"score": 27.648004063756087
},
{
"filename": "src/server/spells/create_component_spell.ts",
"retrieved_chunk": " throw new Error('Missing ts.compDir.')\n }\n if (!config.ts.configPath) {\n throw new Error('Missing ts.configPath.')\n }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const res = await useAi<GeneralComponentResponse>(IPrompts.CREATE_GEN_COMPONENT, description);\n const sourceFile = project.createSourceFile('new_component.tsx', res.message, { scriptKind: ScriptKind.JSX });",
"score": 27.433416858540035
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "export type GuidedEditKeys = `${GuidedEditKeyPrefix}_${number}`;\nexport type GuidedEditResponse = Record<GuidedEditKeys, string>[];\nexport function isGuidedEditResult(obj: GuardValidations): boolean {\n return Array.isArray(obj) && obj.every(item => ['statement', 'above', 'below'].some(test => {\n const guidedEditKey = new RegExp(`^${test}_\\\\d+$`);\n return hasSimilarKey(item, guidedEditKey)\n }));\n}",
"score": 26.854197973516825
},
{
"filename": "src/server/spells/file_editor_spell.ts",
"retrieved_chunk": " ...m,\n [match[0].trim()]: d.slice(match[0].length)\n })\n }\n return { ...m };\n }, {});\n const regex = /\\/\\*\\s*change:.*?\\*\\//gs;\n const editedFile = lined.map(l => {\n const match = l.match(/^\\d+. /);\n const key = match && match[0].trim();",
"score": 24.65939289571564
}
] | typescript | message.reduce((m, d) => ({ ...m, ...d }), {}); |
import fs from 'fs';
import path from "path";
import { sync } from 'fast-glob';
import { isCalledWithNpx, isCliRunning } from "./config";
import languages from "../lib/languages";
import type { OpenAIRequestShapes } from './types';
import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from 'openai';
const langValues = Object.values(languages);
export const codeGPTPrecursor = 'You are BacktickGPT, providing only typescript code responses wrapped with 3 backticks before and after.';
export function deepClone<T>(obj: T): T {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map((item) => deepClone(item) as T) as unknown as T;
}
const result: Record<string, unknown> = {};
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = deepClone((obj as Record<string, unknown>)[key]);
}
}
return result as T;
}
export const isValidName = (name: string): boolean => {
const regex = /^I[A-Z][a-zA-Z]*$/;
return regex.test(name);
};
export const toSnakeCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`).slice(1);
};
export const toTitleCase = (name: string): string => {
if (!isValidName(name)) {
throw new Error("Invalid name format");
}
return name.substr(1).replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
};
export function extractCodeBlock(inputString: string, delimeter: string = '```', languages: string[] = ['typescript', 'json', 'jsx', 'tsx']) {
const langStartTag = (language: string) => language ? `${delimeter}${language}` : delimeter;
for (const language of languages) {
const startTag = langStartTag(language);
if (inputString.includes(startTag)) {
return {
codeBlock: inputString.split(startTag)[1].split(delimeter)[0],
index: inputString.indexOf(startTag) + startTag.length,
};
}
}
if (inputString.includes(delimeter)) {
const index = inputString.indexOf(delimeter) + delimeter.length;
return {
codeBlock: inputString.split(delimeter)[1],
index,
};
}
return {
codeBlock: inputString,
index: 0,
};
};
export function extractCodeBlockPre(inputString: string, index: number): string {
return inputString.substring(0, index)?.trim() || '';
}
export function extractCodeBlockPost(inputString: string, index: number, delimeter: string = '```'): string {
return inputString.substring(index).split(delimeter)[1]?.trim() || '';
}
export function processTextWithCodeBlock(inputString: string): { codeBlock: string; supportingText: string } {
const { codeBlock, index } = extractCodeBlock(inputString);
const preText = extractCodeBlockPre(inputString, index);
const postText = extractCodeBlockPost(inputString, index);
return {
codeBlock,
supportingText: preText + ' ' + postText,
};
}
export function stripWrappedCharacter(inputString: string, wrappedCharacters: string[] = ['"', "'"]): string {
for (const char of wrappedCharacters) {
if (inputString.startsWith(char)) inputString = inputString.slice(1);
if (inputString.endsWith(char)) inputString = inputString.substring(0, inputString.length - 1);
}
return inputString;
}
export function sanitizeName(input: string): string {
// Trim whitespaces and replace consecutive spaces with a single dash
const trimmed = input.trim();
// Remove invalid characters: ~ ^ : ? * [ ] @ { } \ /
const sanitized = trimmed.replace(/[~^:?"*\[\]@{}\\/]+/g, '');
// Limit branch name length to 100 characters
const maxLength = 100;
const shortened = sanitized.slice(0, maxLength);
// Remove leading and trailing period (.)
const noLeadingTrailingPeriods = shortened.replace(/(^\.+|\.+$)/g, '');
// Remove leading and trailing forward slash (-)
const result = noLeadingTrailingPeriods.replace(/(^-+|-+$)/g, '');
return result;
}
export function ensureKeysAreQuoted(jsonString: string): string {
const unquotedKeysRegex = /([{,]\s*)(\w+)\s*:/g;
function quoteKeys(match: unknown, prefix: string, key: string) {
return `${prefix}"${key}":`;
}
return jsonString.replace(unquotedKeysRegex, quoteKeys);
}
export function typeDefinitionToSentence(typeDefinition: string): string {
const typeNameMatch = typeDefinition.match(/export type (\w+)/);
if (!typeNameMatch) {
return 'Invalid type definition provided.';
}
const typeName = typeNameMatch[1];
const properties = [];
const propertyRegex = /(\w+)\s*:\s*([^;]+);/g;
let match;
while ((match = propertyRegex.exec(typeDefinition)) !== null) {
properties.push({ key: match[1], type: match[2].trim().replace(/\s+/g, ' ') });
}
if (properties.length > 0) {
const propertiesDescription = properties
.map((property) => `${property.key} as a ${property.type}`)
.join(', ');
return `${typeName} defines ${propertiesDescription}.`;
} else {
const recordMatch = typeDefinition.match(/Record<(.+),\s*(.+)>/);
if (recordMatch) {
return `${typeName} is a Record ${recordMatch[1]} of ${recordMatch[2]}.`;
}
}
return 'Unable to parse the type definition.';
}
export function getDirPathOf(filePath: string) {
return path.dirname(filePath)
}
export function generateTempFilePath(dir: string, name: string) {
return path.join(dir, `${name}-${Date.now()}.json`)
}
export function getRootDir() {
return isCalledWithNpx ? process.cwd() : path.join(__dirname, isCliRunning ? '../../' : '../');
}
export function getPathOf(name: string, baseDir?: string): string {
return path.join(baseDir || getRootDir(), name);
}
export function getFileParser(fileName: string) {
const extension = path.extname(fileName);
const parser = langValues.find(l => l.fileExtension.includes(extension));
if (!parser) throw 'That parser is undefined!';
return parser.parserName;
}
export function getFileFromDir(file: string, dir: string = __dirname) {
const files = fs.readdirSync(dir);
const fileName = files.find(f => f.startsWith(file));
if (!fileName) throw 'File not found.';
return fs.readFileSync(path.join(dir, fileName), { encoding: 'utf-8' })
}
export function getTargetFile(targetFile: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string | null {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return files.length > 0 ? fileContent : null;
}
export function saveTargetFile(targetFile: string, contents: string, rootDir: string = getRootDir(), ignoredDirectories: string[] = excludeDirectories): string {
const pattern = path.join(rootDir, '**', targetFile);
const files = sync(pattern, {
ignore: ignoredDirectories.map(dir => path.join('**', dir, '**')),
onlyFiles: true,
});
if (!files.length) {
throw 'No file found.';
}
if (files.length > 1) {
throw 'Multiple files were found. Please specifiy with a local folder path.';
}
const fileContent = fs.writeFileSync(files[0], contents, { encoding: 'utf-8' });
console.log({ gotfiles: files, fileContent})
return 'file saved';
}
const excludeDirectories = [
'node_modules',
'vendor',
'dist',
'build',
'.git',
'.svn',
// add other directories to exclude
];
export | function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest { |
return 'messages' in obj;
}
export function isCompletionRequest(obj: OpenAIRequestShapes): obj is CreateCompletionRequest {
return 'prompt' in obj;
}
export function isModerationRequest(obj: OpenAIRequestShapes): obj is CreateModerationRequest {
return 'input' in obj;
} | src/server/util.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "export function isChatResponse<T>(obj: GuardValidations): obj is ChatResponse<T> {\n return 'object' === typeof obj && 'message' in obj && Array.isArray(obj.message);\n}\nexport function isCompletionResponse(obj: GuardValidations): obj is CompletionResponse {\n return 'object' === typeof obj && 'message' in obj && 'string' === typeof obj.message;\n}\nexport function isModerationResponse(obj: GuardValidations): obj is ModerationResponse {\n return 'object' === typeof obj && 'input' in obj;\n}",
"score": 17.951124978430062
},
{
"filename": "src/lib/util.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ConfigPropTypes, DefaultGrammarOrVariants, Grammars, GuardValidations, ModerationResponse } from \"./types\";\nexport function isConfigNestedObject(obj: unknown): obj is Record<string, ConfigPropTypes> {\n return typeof obj === 'object' && obj !== null;\n}\nexport function isDefaultGrammar(obj: DefaultGrammarOrVariants): obj is { default: Grammars } {\n return 'string' === typeof obj.default.name;\n}\nexport function isDefaultGrammarVariants(obj: DefaultGrammarOrVariants): obj is { default: { [prop: string]: Grammars } } {\n return 'undefined' === typeof obj.default.name;\n}",
"score": 17.1660326337909
},
{
"filename": "src/lib/prompts/create_api_prompt.ts",
"retrieved_chunk": "export type CreateApiResult = `const ${CreateApiKey}Api =`;\nexport function isCreateApiResult(obj: GuardValidations): obj is CreateApiResult {\n return 'string' === typeof obj && createApiFormat.test(obj);\n}",
"score": 16.212343236616128
},
{
"filename": "src/server/types.ts",
"retrieved_chunk": "import { CreateChatCompletionRequest, CreateCompletionRequest, CreateModerationRequest } from \"openai\";\nexport type OpenAIRequestShapes = CreateChatCompletionRequest | CreateCompletionRequest | CreateModerationRequest;",
"score": 15.938970814112523
},
{
"filename": "src/lib/prompts/create_api_backend_prompt.ts",
"retrieved_chunk": " 6. Response Technique is the following verbatim text with variables replaced by <>: &&&@@@<RESPONSE_BODY>@@@&&&\n 7. Validate Response: The response returned to the user follows the exact format of Step 6: eg. &&&@@@const customizedApiHandlers: ApiHandler<typeof customizedApi> = {\\n transferred functionality customized around FILE_RELATED_TYPE\\n }@@@&&&` },\n { role: 'user', content: 'FILE_RELATED_TYPE=\\${prompt1}' }\n];\nconst createApiFormat = /^const\\s+\\w+ApiHandlers:\\s+ApiHandler/gim;\ntype CreateApiBackendKey = string;\nexport type CreateApiBackendResult = `const ${CreateApiBackendKey}ApiHandlers: ApiHandler`;\nexport function isCreateApiBackendResult(obj: GuardValidations): obj is CreateApiBackendResult {\n return 'string' === typeof obj && createApiFormat.test(obj);\n}",
"score": 13.310928649723504
}
] | typescript | function isChatRequest(obj: OpenAIRequestShapes): obj is CreateChatCompletionRequest { |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
| const result = parseAction(this.moduleManager.actions, actionText); |
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 69.83071289061695
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 54.281005279699386
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 43.85494740282858
},
{
"filename": "src/make-decision.ts",
"retrieved_chunk": " }\n return {\n role,\n content: `${header}${content}`,\n };\n }\n case \"decision\":\n return {\n role: \"assistant\",\n content: event.actionText,",
"score": 39.9932158495519
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.agentId,\n nestedEvents.flat().join(\"\\n\\n\")\n ),\n };\n }\n private removeErrors(events: Event[]): Event[] {\n const cleaned: Event[] = [];\n for (let i = events.length - 1; i >= 0; i--) {\n const event = events[i];\n if (event.type === \"message\" && event.message.type === \"error\") {",
"score": 39.26530304743874
}
] | typescript | const result = parseAction(this.moduleManager.actions, actionText); |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send | (messageBuilder.error(this.id, result.message)); |
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 46.70946393943647
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " message: 'hello, \"control\"',\n });\n });\n});\n// =============================================================================\nfunction assertValid(text: string): Action {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"error\") throw Error(`Parse failed: ${result.message}`);\n return result.action;\n}",
"score": 43.44983544117401
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "function assertInvalid(text: string): string {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"success\")\n throw Error(\n `Parse succeeded when it should've failed: ${JSON.stringify(\n result.action,\n null,\n 2\n )}`\n );",
"score": 35.19182887978195
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 34.519524162844164
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 30.83975399823266
}
] | typescript | (messageBuilder.error(this.id, result.message)); |
import { parseChatAttempt } from '../parser';
import { IPrompts } from '../../lib/prompts';
import { buildOpenAIRequest, performRequest } from '../request';
import { logAiResult } from '../stats';
import { getConfig } from '../config';
import type { ChatResponse, CompletionResponse, ModerationResponse, OpenAIResults, UseAIResponses } from '../../lib/types';
import { isCompletionRequest } from '../util';
export async function useAi<T = undefined>(promptType?: IPrompts, ...prompts: string[]): Promise<UseAIResponses<T>> {
const config = getConfig();
const retries = parseInt(config.ai.retries, 10);
const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);
const aiResponse: OpenAIResults = {
timestamp: new Date(),
successful: true,
failures: [],
rawResponses: [],
promptTemplate,
promptType: (!promptType ? 'moderation' : promptType) as IPrompts
}
try {
const responseTry = await performRequest(builtRequest);
aiResponse.rawResponses.push(responseTry);
if ('undefined' === typeof responseTry) {
const noChoices = 'Open AI returned no choices.'
aiResponse.failures.push(noChoices);
throw new Error(noChoices);
}
if ('boolean' === typeof responseTry) {
const moderationResponse: ModerationResponse = { ...aiResponse, flagged: responseTry };
console.log('MODERATION RESPONSE :==: ', moderationResponse)
logAiResult<T>({ ...moderationResponse, prompts, model: builtRequest.model });
return moderationResponse as UseAIResponses<T>;
}
if (isCompletionRequest(builtRequest)) {
const completionResponse: CompletionResponse = {
...aiResponse,
message: responseTry
};
console.log('COMPLETION RESPONSE :==: ', completionResponse)
logAiResult<T>({ ...completionResponse, prompts, model: builtRequest.model });
return completionResponse as UseAIResponses<T>;
}
async function resolveAttempt(attempt: string, retriesRemaining: number): Promise< | ChatResponse<T>> { |
try {
const { supportingText, message } = parseChatAttempt<T>(attempt);
const chatResponse = {
...aiResponse,
supportingText,
message
};
logAiResult<T>({ ...chatResponse, prompts, model: builtRequest.model });
console.log('CHAT RESPONSE :==: ', chatResponse)
return chatResponse;
} catch (error) {
const err = error as Error;
if (retriesRemaining > 0 && err.message.startsWith('cannot parse')) {
const repeatedAttempt = await performRequest(builtRequest);
aiResponse.rawResponses.push(repeatedAttempt);
if ('string' !== typeof repeatedAttempt) {
const imparsable = 'Received imparsable resolution during retry.';
aiResponse.failures.push(imparsable);
throw new Error(imparsable);
}
return await resolveAttempt(repeatedAttempt, retriesRemaining - 1);
}
const resolveIssue = 'Critical chat parse error or could not resolve a valid response after ' + retries + ' attempts. ' + (err.message ? 'Parsing error: ' + err.message : '');
aiResponse.failures.push(resolveIssue);
throw new Error(resolveIssue);
}
}
return await resolveAttempt(responseTry, retries) as UseAIResponses<T>;
} catch (error) {
const err = error as Error;
aiResponse.successful = false;
logAiResult({ ...aiResponse, prompts, message: err.message + ' ' + err.stack, model: builtRequest.model });
throw new Error('General use AI failure!\nStack: ' + err.stack);
}
}
| src/server/spells/use_ai_spell.ts | keybittech-wizapp-f75e12d | [
{
"filename": "src/server/request.ts",
"retrieved_chunk": " const completionResponse = await openai.createCompletion(request, openAIRequestOptions);\n console.log({ RAW_COMPLETION: completionResponse.data.choices[0] });\n return completionResponse.data.choices[0].text?.trim();\n } else if (isModerationRequest(request)) {\n const moderationResponse = await openai.createModeration(request, openAIRequestOptions);\n console.log({ RAW_MODERATION: moderationResponse.data.results[0] });\n return moderationResponse.data.results[0]?.flagged;\n }\n}",
"score": 40.71861868283943
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": "import type { ChatResponse, CompletionResponse, ModerationResponse } from \"../lib/types\";\nimport fs from 'fs';\nimport { getConfig } from \"./config\";\nimport { isChatResponse, isCompletionResponse, isModerationResponse } from \"../lib/util\";\nexport function logAiResult<T>(res: ChatResponse<T> | CompletionResponse | ModerationResponse) {\n const config = getConfig();\n const { successful, timestamp, failures, rawResponses, prompts, model, ...metric } = res;\n const duration = ((new Date()).getTime() - (new Date(res.timestamp).getTime())) / 1000;\n let metrics: Record<string, unknown> = {\n pass: successful,",
"score": 32.960272245264285
},
{
"filename": "src/lib/types.ts",
"retrieved_chunk": "}\nexport type ModerationResponse = OpenAIResults & {\n flagged: boolean;\n}\nexport type UseAIResponses<T> = T extends boolean ? ModerationResponse : T extends undefined ? CompletionResponse : ChatResponse<T>;\nexport interface Node {\n type: string;\n text: string;\n children: Node[];\n}",
"score": 31.552999190739648
},
{
"filename": "src/lib/types.ts",
"retrieved_chunk": " rawResponses: (string | boolean | undefined)[];\n failures: string[];\n successful: boolean;\n}\nexport type ChatResponse<T> = OpenAIResults & {\n supportingText?: string;\n message: T;\n}\nexport type CompletionResponse = OpenAIResults & {\n message: string;",
"score": 28.9884954341734
},
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " attempt = stripWrappedCharacter(attempt);\n console.log(\"Parsing a basic attempt: \", attempt);\n const result = validateTypedResponse<T>(attempt);\n return { message: result, supportingText: '' };\n}\nexport let responseValidators = [\n isConvertPurposeResult,\n isFileEditorResult,\n isGuidedEditResult,\n isCreateTypeResponse,",
"score": 26.916308544083307
}
] | typescript | ChatResponse<T>> { |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if | (last(events)?.type === "decision") return; |
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 34.491428873292996
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 28.122339281191486
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 25.098316452561683
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const prevEvent = events[i - 1];\n // console.log(\"REMOVING\", JSON.stringify(prevEvent, null, 2));\n // console.log(\"REMOVING\", JSON.stringify(event, null, 2));\n if (prevEvent.type === \"decision\") {\n i--; // skip the previous action which generated the error\n } else {\n console.error(\"error event was not preceded by an action\");\n }\n continue;\n }",
"score": 24.173885630585698
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.agentId,\n nestedEvents.flat().join(\"\\n\\n\")\n ),\n };\n }\n private removeErrors(events: Event[]): Event[] {\n const cleaned: Event[] = [];\n for (let i = events.length - 1; i >= 0; i--) {\n const event = events[i];\n if (event.type === \"message\" && event.message.type === \"error\") {",
"score": 22.993831593815376
}
] | typescript | (last(events)?.type === "decision") return; |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
| `${agentName(
this.id
)} encountered the following problem while attempting to take action:`
); |
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage(\n messageBuilder.ok(\n agentId,\n `These are the agents in the system:\\n\\n${allAgentIds\n .map((id) => `${agentName(id)} [agentId=${id}]`)\n .join(\"\\n\")}`\n )\n );\n },\n },",
"score": 25.219872345344584
},
{
"filename": "src/console.ts",
"retrieved_chunk": " if (colonIndex >= 0) {\n targetAgentIds = [input.substring(0, colonIndex)];\n content = input.substring(colonIndex + 1);\n } else {\n targetAgentIds = agentIds.filter((id) => id !== AGENT_ID);\n content = input;\n }\n if (content)\n messageBus.send(\n messageBuilder.agentToAgent(AGENT_ID, targetAgentIds, content)",
"score": 24.850324857439947
},
{
"filename": "src/main.ts",
"retrieved_chunk": " const store = new JsonStore<Event[]>(new FileStore([id]));\n // We have to leave room for the agent's next action, which is of unknown size\n const compressionThreshold = Math.round(contextWindowSize[model] * 0.75);\n const memory = new Memory(id, moduleManager, store, compressionThreshold);\n const agent = new Agent(\n id,\n memory,\n messageBus,\n moduleManager,\n actionHandler",
"score": 24.77857559214935
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " message: 'hello, \"control\"',\n });\n });\n});\n// =============================================================================\nfunction assertValid(text: string): Action {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"error\") throw Error(`Parse failed: ${result.message}`);\n return result.action;\n}",
"score": 23.821626320347022
},
{
"filename": "src/action-handler.ts",
"retrieved_chunk": " actionDef.execute({\n context: this.moduleManager.getModuleForAction(actionDef.name)!.context,\n parameters,\n sendMessage: (message) => this.messageBus.send(message),\n });\n }\n}",
"score": 20.197249409051544
}
] | typescript | `${agentName(
this.id
)} encountered the following problem while attempting to take action:`
); |
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import { ModuleManager } from "./module/module-manager";
import { getUsageText } from "./module/util";
import parseAction, { Action } from "./parse-action";
import { MULTILINE_DELIMITER } from "./util";
const moduleManager = new ModuleManager(
"1",
["1"],
[core, notes, messaging, filesystem]
);
test("case 1", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
I am sending you a multi-line message.
This is another line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 2", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
Here is a multi-line message:
This is the first line.
This is the second line.
This is the third line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 3", () => {
assertValid(`
writeFile
path: ./schema/action-dictionary.json
content:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"title": "Action",
"oneOf": [
{
... the old content of action-dictionary.json ...
},
{
"title": "NewActionDefinition",
"description": "This is an example of a new action definition.",
"properties": {
"type": {
"type": "string",
"const": "new-action-definition"
},
"exampleArg": {
"type": "string",
"description": "An example parameter for the new action definition."
}
},
"required": [
"type",
"exampleArg"
],
"additionalProperties": false
}
]
}
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("invalid multiline with no delimiter", () => {
expect(
assertInvalid(`
sendMessage
targetAgentId: 0
message: Hello Control, here's a list of things,
- 9 bottles of ketchup
- 2 pairs of socks
- a very big balloon
`)
).toEqual(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\`)?`
);
});
test("multiline delimiter not starting on its own line", () => {
expect(
assertValid(`
sendMessage
targetAgentId: 0
message: % ff9d7713-0bb0-40d4-823c-5a66de48761b
here is a
multi
line
message
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`).parameters.message
).toBe(
`
here is a
multi
line
message
`.trim()
);
});
test("parameter after multiline parameter", () => {
const { parameters, thoughts } = assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
multi
line
parameter
% ff9d7713-0bb0-40d4-823c-5a66de48761b
thoughts: Trying a multi-line parameter followed by another parameter.
`);
expect(parameters.message).toBe(
`
multi
line
parameter
`.trim()
);
expect(thoughts).toBe(
"Trying a multi-line parameter followed by another parameter."
);
});
test("invalid command name", () => {
expect(assertInvalid("foo")).toBe(
"Unknown action `foo`. Please refer to the list of available actions given in the introductory message."
);
});
test("invalid raw text", () => {
expect(assertInvalid("Hello Control, how are you doing?")).toEqual(
`
Your action could not be parsed. Remember to always format your entire response as an action, like this:
\`\`\`
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
\`\`\`
`.trim()
);
});
test("missing required parameter", () => {
expect(assertInvalid("sendMessage\ntargetAgentId: 0")).toBe(
| `Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
); |
});
test("extra parameter", () => {
expect(assertInvalid("noop\nfoo: bar")).toEqual(
`Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
);
});
describe("quotes", () => {
test("in-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message: hello, "control"
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
test("multi-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message:
${MULTILINE_DELIMITER}
hello, "control"
${MULTILINE_DELIMITER}
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
});
// =============================================================================
function assertValid(text: string): Action {
const result = parseAction(moduleManager.actions, text);
if (result.type === "error") throw Error(`Parse failed: ${result.message}`);
return result.action;
}
function assertInvalid(text: string): string {
const result = parseAction(moduleManager.actions, text);
if (result.type === "success")
throw Error(
`Parse succeeded when it should've failed: ${JSON.stringify(
result.action,
null,
2
)}`
);
return result.message;
}
| src/parse-action.test.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .filter(\n ([name, parameterDef]) =>\n !parameterDef.optional && !(name in parameters)\n )\n .map(([name]) => name);\n if (missingProps.length) {\n return {\n type: \"error\",\n message: `Missing required parameter${\n missingProps.length > 1 ? \"s\" : \"\"",
"score": 24.37001302870754
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " } ${missingProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n const extraProps = Object.keys(parameters).filter(\n (p) => !(p in actionDef.parameters)\n );\n if (extraProps.length) {\n return {\n type: \"error\",\n message: `Extraneous parameter${",
"score": 11.78198278155932
},
{
"filename": "src/module/define-module.ts",
"retrieved_chunk": " name,\n parameters: mapValues(parameters, (parameter) => ({\n optional: false,\n ...parameter,\n })),\n ...definition,\n },\n ]\n )\n ) as any,",
"score": 11.628821972259315
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 10.693305147960434
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " if (colonIndex < 0)\n throw new Error(\n `Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\\`${MULTILINE_DELIMITER}\\`)?`\n );\n const key = line.substring(0, colonIndex).trim();\n let value = line.substring(colonIndex + 1).trim();\n if (!value.startsWith('\"') || !value.endsWith('\"'))\n value = JSON.stringify(value);\n return `\"${key}\": ${value}`;\n })",
"score": 10.457004970973536
}
] | typescript | `Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
); |
import { CODE_BLOCK_DELIMITER, messageBuilder } from "../../message";
import { MULTILINE_DELIMITER, agentName } from "../../util";
import { defineModule } from "../define-module";
import { getUsageText } from "../util";
export default defineModule({
name: "core",
}).with({
pinnedMessage: async ({ agentId, actionDictionary }) =>
`
You are ${agentName(
agentId
)}, a highly capable autonomous entity who is able to perform actions in order to accomplish tasks. The following points should govern everything you do. Read carefully and never forget them:
1) The entirety of your response should always be an invocation of an action, using the following format:
${CODE_BLOCK_DELIMITER}
<action name>
thoughts: <reasoning behind this action>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
Example of a correct response:
${CODE_BLOCK_DELIMITER}
writeNote
thoughts: This seems important since it's fundamental to the way I communicate with the system.
title: Always Remember
content: Encode every response as an action!
${CODE_BLOCK_DELIMITER}
Example of an incorrect response:
${CODE_BLOCK_DELIMITER}
Note to self: always encode every response as an action!
${CODE_BLOCK_DELIMITER}
2) These are the actions at your disposal:
${[...actionDictionary.values()]
.map((actionDef) => `\`${actionDef.name}\` - ${actionDef.description}`)
.join("\n")}
To get help on a specific action, use the \`help\` action with the \`aboutAction\` parameter set to the name of the action you want help with. For example:
${CODE_BLOCK_DELIMITER}
help
aboutAction: writeNote
${CODE_BLOCK_DELIMITER}
You may only invoke actions mentioned in the above list.
*NOTE* You never invoke an action until you have first invoked \`help\` on it so that you know what parameters it expects. Being the careful agent that you are, you do not simply guess parameters that you think would make sense.
3) When passing multiple lines of text as an action parameter, you *MUST* use the multi-line delimiter \`${ | MULTILINE_DELIMITER}\` to enclose the parameter value in its entirety.
Example:
${CODE_BLOCK_DELIMITER} |
writeNote
title: Always Remember
content:
${MULTILINE_DELIMITER}
Encode
every
response
as
an
action!
${MULTILINE_DELIMITER}
${CODE_BLOCK_DELIMITER}
Notice that both the start and end delimiters appear on lines by themselves, and they enclose the \`message\` parameter value in its entirety.
4) Every time you receive a message, you must decide on an action to take. If there's nothing you feel like you need to do at the moment, you can use the \`noop\` action.
5) You are not serving a mere advisory role. You are not a chat bot. You are an autonomous entity who invokes actions to accomplish goals.
`.trim(),
actions: {
noop: {
description: "Do nothing",
async execute() {},
},
help: {
description:
"Get help on a specific action and the parameters it expects.",
parameters: {
aboutAction: {
description: "The name of an action to get help on",
},
},
async execute({
parameters: { aboutAction },
context: { agentId, actionDictionary },
sendMessage,
}) {
const actionDef = actionDictionary.get(aboutAction);
if (!actionDef) {
sendMessage(
messageBuilder.error(
agentId,
`Unknown action \`${aboutAction}\`. Please refer to the list of available actions given in the introductory message.`
)
);
} else {
sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));
}
},
},
},
});
| src/module/definitions/core.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " {\n type: \"message\",\n message: messageBuilder.ok(\n this.agentId,\n `Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`\n ),\n },\n ]);\n const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\\n\\n${summaryContent}`;\n // const summary =",
"score": 57.275549805717446
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " `${index + 1}) \"${text}\" [${complete ? \"COMPLETE\" : \"PENDING\"}]`\n )\n .join(\"\\n\")}`\n : \"You have no goals currently.\";\n return `\nYou are responsible for maintaining your list of goals, based on higher-level objectives which will be given to you. Whenever you start doing something, first add a goal. Whenever you finish doing something, mark it complete. This list of goals will always be pinned to the top of your context and won't be summarized away. Goals should be medium-term (requiring several actions to complete) and concrete. Do not invent goals out of nothing, they should encapsulate instructions that have been given to you.\n${currentGloals}\n`.trim();\n },\n actions: {",
"score": 53.27042934468677
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " const currentNotes = noteTitles.length\n ? `Here are your current notes:\\n\\n${noteTitles\n .map((title) => `- \"${title}\"`)\n .join(\"\\n\")}`\n : \"Your have no notes currently.\";\n return `\nYou can manage your notes using the \\`writeNote\\`, \\`viewNote\\` and \\`deleteNote\\` actions. Use notes to keep track of any important information that you come across that may be of longterm interest. Because notes contain content in addition to a title, you can store larger thoughts here which might not fit into the text of a goal. Your notes list will always be pinned to the top of your context and won't be summarized away.\n${currentNotes}\n`.trim();\n },",
"score": 49.13547921655611
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " if (colonIndex < 0)\n throw new Error(\n `Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\\`${MULTILINE_DELIMITER}\\`)?`\n );\n const key = line.substring(0, colonIndex).trim();\n let value = line.substring(colonIndex + 1).trim();\n if (!value.startsWith('\"') || !value.endsWith('\"'))\n value = JSON.stringify(value);\n return `\"${key}\": ${value}`;\n })",
"score": 48.136442538360576
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "sendMessage\ntargetAgentId: 0\nmessage: Hello Control, here's a list of things,\n- 9 bottles of ketchup\n- 2 pairs of socks\n- a very big balloon\n `)\n ).toEqual(\n `Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\\`)?`\n );",
"score": 45.861784961466654
}
] | typescript | MULTILINE_DELIMITER}\` to enclose the parameter value in its entirety.
Example:
${CODE_BLOCK_DELIMITER} |
import { defineModule } from "../define-module";
import { messageBuilder } from "../../message";
import { Store } from "../../store";
import FileStore from "../../store/file-store";
import JsonStore from "../../store/json-store";
interface Goal {
text: string;
complete: boolean;
}
const KEY = "goals";
export default defineModule<Store<Goal[]>>({
name: "goals",
createState: ({ agentId }) => new JsonStore(new FileStore([agentId])),
}).with({
async pinnedMessage({ state }) {
const goals = (await state.get(KEY)) || [];
const currentGloals = goals.length
? `This is your current goal list:\n\n${goals
.map(
({ text, complete }, index) =>
`${index + 1}) "${text}" [${complete ? "COMPLETE" : "PENDING"}]`
)
.join("\n")}`
: "You have no goals currently.";
return `
You are responsible for maintaining your list of goals, based on higher-level objectives which will be given to you. Whenever you start doing something, first add a goal. Whenever you finish doing something, mark it complete. This list of goals will always be pinned to the top of your context and won't be summarized away. Goals should be medium-term (requiring several actions to complete) and concrete. Do not invent goals out of nothing, they should encapsulate instructions that have been given to you.
${currentGloals}
`.trim();
},
actions: {
addGoal: {
description: "Add a new goal at the end of your goals list.",
parameters: {
goal: {
description:
"A summary of what you want to achieve (keep this relatively short but information dense)",
},
},
async execute({
parameters: { goal },
context: { agentId, state },
sendMessage,
}) {
const goals = (await state.get(KEY)) || [];
await state.set(KEY, [...goals, { text: goal, complete: false }]);
| sendMessage(messageBuilder.ok(agentId, "Goal added.")); |
},
},
completeGoal: {
description: "Mark a goal as complete.",
parameters: {
goalNumber: {
description: "The number of the goal you want to mark as complete",
},
},
async execute({
parameters: { goalNumber },
context: { agentId, state },
sendMessage,
}) {
const idx = parseInt(goalNumber) - 1;
const goals = (await state.get(KEY)) || [];
if (isNaN(idx) || idx < 0 || idx >= goals.length)
return sendMessage(
messageBuilder.error(agentId, `Invalid goal index: ${goalNumber}`)
);
await state.set(KEY, [
...goals.slice(0, idx),
{ ...goals[idx], complete: true },
...goals.slice(idx + 1),
]);
sendMessage(messageBuilder.ok(agentId, "Goal marked complete."));
},
},
},
});
| src/module/definitions/goals.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " },\n async execute({\n parameters: { title, content },\n context: { agentId, state },\n sendMessage,\n }) {\n await state.set(title, content);\n sendMessage(\n messageBuilder.ok(\n agentId,",
"score": 43.83892099758937
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " },\n },\n async execute({\n parameters: { title },\n context: { agentId, state },\n sendMessage,\n }) {\n const content = await state.get(title);\n if (content) {\n sendMessage(",
"score": 38.85461816512987
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " }) {\n if (await state.delete(title)) {\n sendMessage(messageBuilder.ok(agentId, `Deleted note \"${title}\".`));\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },",
"score": 27.291862596386505
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " description: \"Delete a note.\",\n parameters: {\n title: {\n description: \"The title of the note to delete\",\n },\n },\n async execute({\n parameters: { title },\n context: { agentId, state },\n sendMessage,",
"score": 24.89658433044272
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await unlink(path);\n sendMessage(messageBuilder.ok(agentId, `Deleted ${path}.`));",
"score": 23.894527650421633
}
] | typescript | sendMessage(messageBuilder.ok(agentId, "Goal added.")); |
import { CODE_BLOCK_DELIMITER } from "./message";
import { ActionDefinition } from "./module/action-definition";
import { getUsageText } from "./module/util";
import { MULTILINE_DELIMITER } from "./util";
type ParseResult =
| {
type: "success";
action: Action;
}
| { type: "error"; message: string };
export interface Action {
actionDef: ActionDefinition;
thoughts?: string;
parameters: Record<string, string>;
}
export default function parseAction(
actionDictionary: Map<string, ActionDefinition>,
text: string
): ParseResult {
try {
text = text.trim();
if (!/^\S+(?=\n|$)/.test(text.split("\n")[0])) {
return {
type: "error",
message: `
Your action could not be parsed. Remember to always format your entire response as an action, like this:
${CODE_BLOCK_DELIMITER}
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
`.trim(),
};
}
text = `name: ${text}`;
const jsonText =
"{" +
text
.split(MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => {
if (i % 2 === 0) return part;
return JSON.stringify(part) + "\n";
})
.join("")
.split("\n")
.filter(Boolean)
.map((line) => {
const colonIndex = line.indexOf(":");
if (colonIndex < 0)
throw new Error(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`${MULTILINE_DELIMITER}\`)?`
);
const key = line.substring(0, colonIndex).trim();
let value = line.substring(colonIndex + 1).trim();
if (!value.startsWith('"') || !value.endsWith('"'))
value = JSON.stringify(value);
return `"${key}": ${value}`;
})
.join(",") +
"}";
const { name, thoughts, ...parameters } = JSON.parse(jsonText);
const actionDef = actionDictionary.get(name);
if (!actionDef)
return {
type: "error",
message: `Unknown action \`${name}\`. Please refer to the list of available actions given in the introductory message.`,
};
const missingProps = Object.entries(actionDef.parameters)
.filter(
([name, parameterDef]) =>
| !parameterDef.optional && !(name in parameters)
)
.map(([name]) => name); |
if (missingProps.length) {
return {
type: "error",
message: `Missing required parameter${
missingProps.length > 1 ? "s" : ""
} ${missingProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
const extraProps = Object.keys(parameters).filter(
(p) => !(p in actionDef.parameters)
);
if (extraProps.length) {
return {
type: "error",
message: `Extraneous parameter${
extraProps.length > 1 ? "s" : ""
} ${extraProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
return { type: "success", action: { actionDef, thoughts, parameters } };
} catch (e: any) {
return {
type: "error",
message: e.message,
};
}
}
| src/parse-action.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " if (!actionDef) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Unknown action \\`${aboutAction}\\`. Please refer to the list of available actions given in the introductory message.`\n )\n );\n } else {\n sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef)));\n }",
"score": 52.110208702665055
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " );\n expect(thoughts).toBe(\n \"Trying a multi-line parameter followed by another parameter.\"\n );\n});\ntest(\"invalid command name\", () => {\n expect(assertInvalid(\"foo\")).toBe(\n \"Unknown action `foo`. Please refer to the list of available actions given in the introductory message.\"\n );\n});",
"score": 51.2262164937425
},
{
"filename": "src/module/util.ts",
"retrieved_chunk": "import { CODE_BLOCK_DELIMITER } from \"../message\";\nimport { ActionDefinition } from \"./action-definition\";\nexport function getUsageText(actionDef: ActionDefinition): string {\n return `Usage:\n${CODE_BLOCK_DELIMITER}\n${actionDef.name}\nthoughts: <reasoning behind this action> (optional)${Object.entries(\n actionDef.parameters\n )\n .map(([name, { description }]) =>",
"score": 40.416451812201906
},
{
"filename": "src/module/util.ts",
"retrieved_chunk": " name === \"name\"\n ? undefined\n : `\\n${name}: <${description.toLowerCase()}>${\n actionDef.parameters[name].optional ? \" (optional)\" : \"\"\n }`\n )\n .filter(Boolean)\n .join(\"\")}\n${CODE_BLOCK_DELIMITER}`;\n}",
"score": 39.29465252189638
},
{
"filename": "src/module/module-manager.ts",
"retrieved_chunk": " );\n this.actionToModule = new Map();\n for (const module of this.modules) {\n for (const actionDef of Object.values(module.moduleDef.actions)) {\n this.actionToModule.set(actionDef.name, module);\n }\n }\n }\n getModuleForAction(name: string): ModuleInstance | undefined {\n return this.actionToModule.get(name);",
"score": 29.597572988513058
}
] | typescript | !parameterDef.optional && !(name in parameters)
)
.map(([name]) => name); |
import { google } from "googleapis";
import puppeteer from "puppeteer";
import TurndownService from "turndown";
import { messageBuilder } from "../../message";
import { Model, contextWindowSize, createChatCompletion } from "../../openai";
import { model } from "../../parameters";
import {
AVG_CHARACTERS_PER_TOKEN,
AVG_WORDS_PER_TOKEN,
countTokens,
} from "../../util";
import { defineModule } from "../define-module";
export default defineModule({
name: "web",
}).with({
actions: {
searchWeb: {
description: "Search the web.",
parameters: {
searchString: {
description: "The string to search for",
},
},
async execute({
parameters: { searchString },
context: { agentId },
sendMessage,
}) {
const items = await getSearchResults(searchString);
if (!items) {
return sendMessage(
messageBuilder.ok(agentId, "Search returned no results.")
);
}
sendMessage(
messageBuilder.ok(
agentId,
`Search results:\n\n${items
.map((item) => `- Title: "${item.title}"\n URL: ${item.link}`)
.join("\n\n")}`
)
);
},
},
readPage: {
description: "View a markdown summary of a web page.",
parameters: {
url: {
description: "The URL of the web page to read",
},
},
async execute({
parameters: { url },
context: { agentId },
sendMessage,
}) {
try {
| const maxCompletionTokens = contextWindowSize[model] / 4; |
// console.log({ maxCompletionTokens });
const pageSummary = await getPageSummary(
model,
maxCompletionTokens,
url
);
sendMessage(
messageBuilder.ok(
agentId,
`Here is a summarized markdown version of the page, in a series of summarized chunks:\n\n${pageSummary}`
)
);
} catch (e: any) {
sendMessage(
messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
);
}
},
},
},
});
export async function getSearchResults(searchString: string) {
const { data } = await google.customsearch("v1").cse.list({
q: searchString,
cx: process.env.GOOGLE_SEARCH_ENGINE_ID,
key: process.env.GOOGLE_API_KEY,
});
return data.items;
}
export async function getPageSummary(
model: Model,
maxSummaryTokens: number,
url: string
) {
const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9);
console.log("Initializing...");
const browser = await puppeteer.launch();
const page = await browser.newPage();
const turndownService = new TurndownService().addRule(
"remove-extraneous-tags",
{
filter: ["style", "script", "img"],
replacement: () => "",
}
);
console.log(`Reading page at ${url}...`);
await page.goto(url);
const htmlContent = await page.content();
// console.log(htmlContent);
console.log(`HTML tokens: ${countTokens(htmlContent)}`);
turndownService.remove(["style", "script"]);
const markdownContent = turndownService
.turndown(htmlContent)
.replace(/\\_/g, "_");
const markdownTokens = countTokens(markdownContent);
console.log(`Markdown tokens: ${markdownTokens}`);
const chunks: string[] = [];
let currentChunkLines: string[] = [];
let currentChunkTokens = 0;
for (const line of markdownContent.split("\n")) {
const lineTokens = countTokens(line);
if (currentChunkTokens + lineTokens > maxCompletionTokens) {
chunks.push(currentChunkLines.join("\n"));
currentChunkLines = [];
currentChunkTokens = 0;
}
currentChunkLines.push(line);
currentChunkTokens += lineTokens;
}
let lastChunk = currentChunkLines.join("\n");
if (countTokens(lastChunk) > maxCompletionTokens) {
const characterLimit = Math.round(
maxCompletionTokens * AVG_CHARACTERS_PER_TOKEN
);
console.log(
`Truncating final chunk at ${characterLimit} characters:\n\n${lastChunk}`
);
lastChunk = lastChunk.substring(0, characterLimit);
}
chunks.push(lastChunk);
// console.log(
// chunks
// .map((chunk) => `CHUNK (${countTokens(chunk)}):\n\n${chunk}\n\n`)
// .join("")
// );
console.log(
`Total chunks: ${chunks.length} (${Math.round(
markdownTokens / chunks.length
)} tokens per chunk)`
);
const maxChunkSummaryTokens = Math.round(maxSummaryTokens / chunks.length);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryWords = Math.round(
maxChunkSummaryTokens * AVG_WORDS_PER_TOKEN
);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryCharacters = Math.round(
maxChunkSummaryTokens * AVG_CHARACTERS_PER_TOKEN
);
// const summaryLimitText = `${maxChunkSummaryWords} words`;
const chunkSummaryLimitText = `${maxChunkSummaryCharacters} characters`;
console.log(
`Max tokens per chunk summary: ${maxChunkSummaryTokens} (${chunkSummaryLimitText})`
);
console.log("Summarizing chunks...");
const summarizedChunks = await Promise.all(
chunks.map(async (chunk) =>
createChatCompletion({
model,
messages: [
{
role: "user",
content: `Modify the following markdown excerpt only as much as necessary to bring it under a maximum of ${chunkSummaryLimitText}, preserving the most essential information. In particular, try to preserve links (example: \`[my special link](https://foo.bar/baz/)\`). Write this in the same voice as the original text; do not speak in the voice of someone who is describing it to someone else. For instance, don't use phrases like "The article talks about...". Excerpt to summarize follows:\n\n=============\n\n${chunk}`,
},
],
})
)
);
const summary = summarizedChunks
.map(
(chunk) =>
`=== SUMMARIZED CHUNK (${countTokens(
chunk
)} tokens) ===\n\n${chunk}\n\n`
)
.join("");
// console.log(`Summary:\n\n${summary}\n`);
console.log(`Summary tokens: ${countTokens(summary)}`);
await browser.close();
return summary;
}
| src/module/definitions/web.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " description: \"The path of the directory you want to inspect\",\n },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {",
"score": 23.237381544424302
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " description: \"Delete a note.\",\n parameters: {\n title: {\n description: \"The title of the note to delete\",\n },\n },\n async execute({\n parameters: { title },\n context: { agentId, state },\n sendMessage,",
"score": 21.056482117301798
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " parameters: {\n goalNumber: {\n description: \"The number of the goal you want to mark as complete\",\n },\n },\n async execute({\n parameters: { goalNumber },\n context: { agentId, state },\n sendMessage,\n }) {",
"score": 20.268094612117046
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " path: {\n description: \"The path of the file you want to inspect\",\n },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;",
"score": 20.126810735129055
},
{
"filename": "src/module/definitions/core.ts",
"retrieved_chunk": " aboutAction: {\n description: \"The name of an action to get help on\",\n },\n },\n async execute({\n parameters: { aboutAction },\n context: { agentId, actionDictionary },\n sendMessage,\n }) {\n const actionDef = actionDictionary.get(aboutAction);",
"score": 18.56044383147895
}
] | typescript | const maxCompletionTokens = contextWindowSize[model] / 4; |
import { ChatCompletionRequestMessage } from "openai";
import { Event } from "./memory";
import { createChatCompletion } from "./openai";
import { model } from "./parameters";
import { messageSourceName } from "./util";
export default async function makeDecision(events: Event[]): Promise<string> {
console.log(`Reflecting on ${events.length} events...`);
const t0 = Date.now();
const messages = events.map(toOpenAiMessage);
// console.log(JSON.stringify(messages, null, 2));
const responseContent = await createChatCompletion({
model,
messages,
temperature: 0.0,
});
console.log(
`Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`
);
return responseContent;
}
// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded
export function toOpenAiMessage(event: Event): ChatCompletionRequestMessage {
switch (event.type) {
case "message": {
const { type: messageType, source, content } = event.message;
const role = source.type === "system" ? "system" : "user";
let header: string;
switch (messageType) {
case "spontaneous":
case "ok":
header = "";
break;
case "agentToAgent":
header = `--- MESSAGE FROM ${messageSourceName(
source
).toUpperCase()} ---\n\n`;
break;
case "error":
header = "--- ERROR ---\n\n";
break;
}
return {
role,
content | : `${header}${content}`,
}; |
}
case "decision":
return {
role: "assistant",
content: event.actionText,
};
}
}
| src/make-decision.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const { name, pinnedMessage } = module.moduleDef;\n if (!pinnedMessage) return [];\n const content = await pinnedMessage(module.context);\n if (!content) return [];\n return [`--- ${name.toUpperCase()} ---\\n\\n${content}`];\n })\n );\n return {\n type: \"message\",\n message: messageBuilder.spontaneous(",
"score": 13.97967348007145
},
{
"filename": "src/parameters.ts",
"retrieved_chunk": " break;\n default:\n throw Error(`Unrecognized OpenAI model: '${modelText}'`);\n}\nconsole.log(`Model: ${model}`);",
"score": 13.678681893673245
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 13.430386695205298
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " targetNames = [\"System\"];\n }\n console.log(\n `${sourceName} -> ${targetNames.join(\", \")}:\\n\\n${\n toOpenAiMessage(event).content\n }\\n\\n=============\\n`\n );\n }\n}\nfunction countTokens(event: Event) {",
"score": 12.834435858092997
},
{
"filename": "src/console.ts",
"retrieved_chunk": " messageBus.subscribe((message) => {\n if (message.targetAgentIds && !message.targetAgentIds.includes(AGENT_ID))\n return;\n console.log(`\\n${message.content}\\n`);\n rl.prompt();\n });\n rl.on(\"line\", (input) => {\n const colonIndex = -1; //input.indexOf(\":\");\n let targetAgentIds: string[];\n let content: string;",
"score": 11.730776756706717
}
] | typescript | : `${header}${content}`,
}; |
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import { ModuleManager } from "./module/module-manager";
import { getUsageText } from "./module/util";
import parseAction, { Action } from "./parse-action";
import { MULTILINE_DELIMITER } from "./util";
const moduleManager = new ModuleManager(
"1",
["1"],
[core, notes, messaging, filesystem]
);
test("case 1", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
I am sending you a multi-line message.
This is another line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 2", () => {
assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
Hello Control, this is Agent 1.
Here is a multi-line message:
This is the first line.
This is the second line.
This is the third line.
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("case 3", () => {
assertValid(`
writeFile
path: ./schema/action-dictionary.json
content:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
{
"$schema": "http://json-schema.org/draft-07/schema#",
"type": "object",
"title": "Action",
"oneOf": [
{
... the old content of action-dictionary.json ...
},
{
"title": "NewActionDefinition",
"description": "This is an example of a new action definition.",
"properties": {
"type": {
"type": "string",
"const": "new-action-definition"
},
"exampleArg": {
"type": "string",
"description": "An example parameter for the new action definition."
}
},
"required": [
"type",
"exampleArg"
],
"additionalProperties": false
}
]
}
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`);
});
test("invalid multiline with no delimiter", () => {
expect(
assertInvalid(`
sendMessage
targetAgentId: 0
message: Hello Control, here's a list of things,
- 9 bottles of ketchup
- 2 pairs of socks
- a very big balloon
`)
).toEqual(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`% ff9d7713-0bb0-40d4-823c-5a66de48761b\`)?`
);
});
test("multiline delimiter not starting on its own line", () => {
expect(
assertValid(`
sendMessage
targetAgentId: 0
message: % ff9d7713-0bb0-40d4-823c-5a66de48761b
here is a
multi
line
message
% ff9d7713-0bb0-40d4-823c-5a66de48761b
`).parameters.message
).toBe(
`
here is a
multi
line
message
`.trim()
);
});
test("parameter after multiline parameter", () => {
const { parameters, thoughts } = assertValid(`
sendMessage
targetAgentId: 0
message:
% ff9d7713-0bb0-40d4-823c-5a66de48761b
multi
line
parameter
% ff9d7713-0bb0-40d4-823c-5a66de48761b
thoughts: Trying a multi-line parameter followed by another parameter.
`);
expect(parameters.message).toBe(
`
multi
line
parameter
`.trim()
);
expect(thoughts).toBe(
"Trying a multi-line parameter followed by another parameter."
);
});
test("invalid command name", () => {
expect(assertInvalid("foo")).toBe(
"Unknown action `foo`. Please refer to the list of available actions given in the introductory message."
);
});
test("invalid raw text", () => {
expect(assertInvalid("Hello Control, how are you doing?")).toEqual(
`
Your action could not be parsed. Remember to always format your entire response as an action, like this:
\`\`\`
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
\`\`\`
`.trim()
);
});
test("missing required parameter", () => {
expect(assertInvalid("sendMessage\ntargetAgentId: 0")).toBe(
`Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
);
});
test("extra parameter", () => {
expect(assertInvalid("noop\nfoo: bar")).toEqual(
`Extraneous parameter \`foo\`. ${getUsageText(core.actions.noop)}`
);
});
describe("quotes", () => {
test("in-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message: hello, "control"
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
test("multi-line parameter", () => {
const action = assertValid(`
sendMessage
targetAgentId: 0
message:
${MULTILINE_DELIMITER}
hello, "control"
${MULTILINE_DELIMITER}
`);
expect(action.actionDef.name).toBe("sendMessage");
expect(action.parameters).toEqual({
targetAgentId: "0",
message: 'hello, "control"',
});
});
});
// =============================================================================
function assertValid(text: string): Action {
| const result = parseAction(moduleManager.actions, text); |
if (result.type === "error") throw Error(`Parse failed: ${result.message}`);
return result.action;
}
function assertInvalid(text: string): string {
const result = parseAction(moduleManager.actions, text);
if (result.type === "success")
throw Error(
`Parse succeeded when it should've failed: ${JSON.stringify(
result.action,
null,
2
)}`
);
return result.message;
}
| src/parse-action.test.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.ts",
"retrieved_chunk": "export interface Action {\n actionDef: ActionDefinition;\n thoughts?: string;\n parameters: Record<string, string>;\n}\nexport default function parseAction(\n actionDictionary: Map<string, ActionDefinition>,\n text: string\n): ParseResult {\n try {",
"score": 23.79758066826431
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " text = text.trim();\n if (!/^\\S+(?=\\n|$)/.test(text.split(\"\\n\")[0])) {\n return {\n type: \"error\",\n message: `\nYour action could not be parsed. Remember to always format your entire response as an action, like this:\n${CODE_BLOCK_DELIMITER}\n<action name>\n<arg 1 name>: <prop value>\n<arg 2 name>: <prop value>",
"score": 18.634923976401566
},
{
"filename": "src/module/util.ts",
"retrieved_chunk": "import { CODE_BLOCK_DELIMITER } from \"../message\";\nimport { ActionDefinition } from \"./action-definition\";\nexport function getUsageText(actionDef: ActionDefinition): string {\n return `Usage:\n${CODE_BLOCK_DELIMITER}\n${actionDef.name}\nthoughts: <reasoning behind this action> (optional)${Object.entries(\n actionDef.parameters\n )\n .map(([name, { description }]) =>",
"score": 17.50986516781668
},
{
"filename": "src/action-handler.ts",
"retrieved_chunk": "import { ModuleManager } from \"./module/module-manager\";\nimport { MessageBus } from \"./message-bus\";\nimport { Action } from \"./parse-action\";\nexport default class ActionHandler {\n constructor(\n private agentIds: string[],\n private messageBus: MessageBus,\n private moduleManager: ModuleManager\n ) {}\n async handle(agentId: string, { actionDef, parameters }: Action) {",
"score": 17.286514017393426
},
{
"filename": "src/task-queue.test.ts",
"retrieved_chunk": " await sleep(500);\n expect(taskQueue.length).toBeLessThanOrEqual(1);\n expect(numTasksRun).toBeGreaterThanOrEqual(3);\n expect(numTasksRun).toBeLessThanOrEqual(5);\n });\n });\n});",
"score": 16.517627691302224
}
] | typescript | const result = parseAction(moduleManager.actions, text); |
import { CODE_BLOCK_DELIMITER, messageBuilder } from "../../message";
import { MULTILINE_DELIMITER, agentName } from "../../util";
import { defineModule } from "../define-module";
import { getUsageText } from "../util";
export default defineModule({
name: "core",
}).with({
pinnedMessage: async ({ agentId, actionDictionary }) =>
`
You are ${agentName(
agentId
)}, a highly capable autonomous entity who is able to perform actions in order to accomplish tasks. The following points should govern everything you do. Read carefully and never forget them:
1) The entirety of your response should always be an invocation of an action, using the following format:
${CODE_BLOCK_DELIMITER}
<action name>
thoughts: <reasoning behind this action>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
Example of a correct response:
${CODE_BLOCK_DELIMITER}
writeNote
thoughts: This seems important since it's fundamental to the way I communicate with the system.
title: Always Remember
content: Encode every response as an action!
${CODE_BLOCK_DELIMITER}
Example of an incorrect response:
${CODE_BLOCK_DELIMITER}
Note to self: always encode every response as an action!
${CODE_BLOCK_DELIMITER}
2) These are the actions at your disposal:
${[...actionDictionary.values()]
.map((actionDef) => `\`${actionDef.name}\` - ${actionDef.description}`)
.join("\n")}
To get help on a specific action, use the \`help\` action with the \`aboutAction\` parameter set to the name of the action you want help with. For example:
${CODE_BLOCK_DELIMITER}
help
aboutAction: writeNote
${CODE_BLOCK_DELIMITER}
You may only invoke actions mentioned in the above list.
*NOTE* You never invoke an action until you have first invoked \`help\` on it so that you know what parameters it expects. Being the careful agent that you are, you do not simply guess parameters that you think would make sense.
3) When passing multiple lines of text as an action parameter, you *MUST* use the multi-line delimiter \`${MULTILINE_DELIMITER}\` to enclose the parameter value in its entirety.
Example:
${CODE_BLOCK_DELIMITER}
writeNote
title: Always Remember
content:
${MULTILINE_DELIMITER}
Encode
every
response
as
an
action!
${MULTILINE_DELIMITER}
${CODE_BLOCK_DELIMITER}
Notice that both the start and end delimiters appear on lines by themselves, and they enclose the \`message\` parameter value in its entirety.
4) Every time you receive a message, you must decide on an action to take. If there's nothing you feel like you need to do at the moment, you can use the \`noop\` action.
5) You are not serving a mere advisory role. You are not a chat bot. You are an autonomous entity who invokes actions to accomplish goals.
`.trim(),
actions: {
noop: {
description: "Do nothing",
async execute() {},
},
help: {
description:
"Get help on a specific action and the parameters it expects.",
parameters: {
aboutAction: {
description: "The name of an action to get help on",
},
},
async execute({
parameters: { aboutAction },
context: { agentId, actionDictionary },
sendMessage,
}) {
const actionDef = actionDictionary.get(aboutAction);
if (!actionDef) {
sendMessage(
messageBuilder.error(
agentId,
`Unknown action \`${aboutAction}\`. Please refer to the list of available actions given in the introductory message.`
)
);
} else {
| sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef))); |
}
},
},
},
});
| src/module/definitions/core.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " .join(\",\") +\n \"}\";\n const { name, thoughts, ...parameters } = JSON.parse(jsonText);\n const actionDef = actionDictionary.get(name);\n if (!actionDef)\n return {\n type: \"error\",\n message: `Unknown action \\`${name}\\`. Please refer to the list of available actions given in the introductory message.`,\n };\n const missingProps = Object.entries(actionDef.parameters)",
"score": 58.447101905148024
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " );\n expect(thoughts).toBe(\n \"Trying a multi-line parameter followed by another parameter.\"\n );\n});\ntest(\"invalid command name\", () => {\n expect(assertInvalid(\"foo\")).toBe(\n \"Unknown action `foo`. Please refer to the list of available actions given in the introductory message.\"\n );\n});",
"score": 39.19719473266043
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " } ${missingProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n const extraProps = Object.keys(parameters).filter(\n (p) => !(p in actionDef.parameters)\n );\n if (extraProps.length) {\n return {\n type: \"error\",\n message: `Extraneous parameter${",
"score": 22.96000465799426
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 21.902979831009986
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " }) {\n if (await state.delete(title)) {\n sendMessage(messageBuilder.ok(agentId, `Deleted note \"${title}\".`));\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },",
"score": 21.688271815750085
}
] | typescript | sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef))); |
import { Event } from ".";
import makeDecision, { toOpenAiMessage } from "../make-decision";
import { messageBuilder } from "../message";
import { ModuleManager } from "../module/module-manager";
import { Store } from "../store";
import {
AVG_WORDS_PER_TOKEN,
agentName,
countTokens as countTokensInText,
messageSourceName,
} from "../util";
export class Memory {
private firstRetrieval = true;
constructor(
private agentId: string,
private moduleManager: ModuleManager,
private store: Store<Event[]>,
private compressionThreshold: number
) {}
async append(event: Event): Promise<Event[]> {
this.printEvent(event);
let events = await this.retrieve();
if (event.type === "message" && event.message.type === "ok") {
// After an "ok" message is sent, remove all errors and their antecedents from memory,
// since agents tend to repeat mistakes rather than learning from them.
events = this.removeErrors(events);
}
events.push(event);
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
return events;
}
async retrieve(): Promise<Event[]> {
const introduction = await this.getIntroduction();
const storedEvents = await this.store.get(this.key);
let events = [
introduction,
...(storedEvents || [{ type: "decision", actionText: "noop" }]),
];
if (this.firstRetrieval) {
this.firstRetrieval = false;
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
}
// events.forEach((event) => this.printEvent(event));
return events;
}
private async getIntroduction(): Promise<Event> {
const nestedEvents = await Promise.all(
this.moduleManager.modules.map(async (module): Promise<string[]> => {
const { name, pinnedMessage } = module.moduleDef;
if (!pinnedMessage) return [];
const content = await pinnedMessage(module.context);
if (!content) return [];
return [`--- ${name.toUpperCase()} ---\n\n${content}`];
})
);
return {
type: "message",
message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
};
}
private removeErrors(events: Event[]): Event[] {
const cleaned: Event[] = [];
for (let i = events.length - 1; i >= 0; i--) {
const event = events[i];
if (event.type === "message" && event.message.type === "error") {
const prevEvent = events[i - 1];
// console.log("REMOVING", JSON.stringify(prevEvent, null, 2));
// console.log("REMOVING", JSON.stringify(event, null, 2));
if (prevEvent.type === "decision") {
i--; // skip the previous action which generated the error
} else {
console.error("error event was not preceded by an action");
}
continue;
}
cleaned.push(event);
}
cleaned.reverse();
// console.log({ events, cleaned });
return cleaned;
}
/**
* Compress the event history when it becomes too large in order to free up the context window.
*/
private async summarize(events: Event[]): Promise<Event[]> {
if (!events.length) return [];
const cumulativeTokenCounts = this.getCumulativeTokenCounts(events);
const totalTokenCount =
cumulativeTokenCounts[cumulativeTokenCounts.length - 1];
const thresholdOverrun = totalTokenCount - this.compressionThreshold;
const truncationThreshold =
cumulativeTokenCounts[0] +
Math.max(
thresholdOverrun,
Math.floor((totalTokenCount - cumulativeTokenCounts[0]) / 2)
);
// console.log(
// `Token count: ${totalTokenCount}\nRemaining context space: ${-thresholdOverrun}`
// );
// console.log({
// compressionThreshold: this.compressionThreshold,
// truncationThreshold,
// thresholdOverrun,
// cumulativeTokenCounts,
// });
if (thresholdOverrun > 0) {
let i = 1;
// prettier-ignore
for (; i < events.length && cumulativeTokenCounts[i - 1] <= truncationThreshold; i++);
// prettier-ignore
for (; i > 0 && cumulativeTokenCounts[i - 1] > this.compressionThreshold; i--);
i = Math.max(i, 3);
const precedingTokens = cumulativeTokenCounts[i - 1];
// console.log({ truncationIndex: i, precedingTokens });
const summaryWordLimit = Math.floor(
(this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6
);
const eventsToSummarize = events.slice(0, i);
// console.log(
// `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize
// .map(countTokens)
// .reduce((sum, next) => sum + next, 0)} tokens)`
// );
const summaryContent = await | makeDecision([
...eventsToSummarize,
{ |
type: "message",
message: messageBuilder.ok(
this.agentId,
`Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`
),
},
]);
const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\n\n${summaryContent}`;
// const summary =
// "Several events are omitted here to free up space in your context window.";
const summaryEvent: Event = {
type: "message",
message: messageBuilder.spontaneous(this.agentId, summary),
};
const summaryTokens = countTokens(summaryEvent);
const tokenSavings =
precedingTokens - summaryTokens - cumulativeTokenCounts[0];
if (tokenSavings > 0) {
// console.log(
// `Summarized events, saving ${tokenSavings} tokens:\n\n${summary}`
// );
const newEvents = [events[0], summaryEvent, ...events.slice(i)];
// const newCumulativeTokenCounts =
// this.getCumulativeTokenCounts(newEvents);
// console.log({ newCumulativeTokenCounts });
return newEvents;
}
}
return events;
}
private getCumulativeTokenCounts(events: Event[]) {
return events.reduce((counts, event) => {
const prevSum = counts.length ? counts[counts.length - 1] : 0;
counts.push(prevSum + countTokens(event));
return counts;
}, [] as number[]);
}
private get key() {
return "memory";
}
private printEvent(event: Event) {
let sourceName: string;
let targetNames: string[];
if (event.type === "message") {
const { message } = event;
sourceName = messageSourceName(message.source);
targetNames = message.targetAgentIds?.map(agentName);
} else {
sourceName = agentName(this.agentId);
targetNames = ["System"];
}
console.log(
`${sourceName} -> ${targetNames.join(", ")}:\n\n${
toOpenAiMessage(event).content
}\n\n=============\n`
);
}
}
function countTokens(event: Event) {
return countTokensInText(toOpenAiMessage(event).content);
}
| src/memory/memory.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/make-decision.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport { Event } from \"./memory\";\nimport { createChatCompletion } from \"./openai\";\nimport { model } from \"./parameters\";\nimport { messageSourceName } from \"./util\";\nexport default async function makeDecision(events: Event[]): Promise<string> {\n console.log(`Reflecting on ${events.length} events...`);\n const t0 = Date.now();\n const messages = events.map(toOpenAiMessage);\n // console.log(JSON.stringify(messages, null, 2));",
"score": 25.48501888651117
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " console.log(`HTML tokens: ${countTokens(htmlContent)}`);\n turndownService.remove([\"style\", \"script\"]);\n const markdownContent = turndownService\n .turndown(htmlContent)\n .replace(/\\\\_/g, \"_\");\n const markdownTokens = countTokens(markdownContent);\n console.log(`Markdown tokens: ${markdownTokens}`);\n const chunks: string[] = [];\n let currentChunkLines: string[] = [];\n let currentChunkTokens = 0;",
"score": 21.01568334385945
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " // const summaryLimitText = `${maxChunkSummaryWords} words`;\n const chunkSummaryLimitText = `${maxChunkSummaryCharacters} characters`;\n console.log(\n `Max tokens per chunk summary: ${maxChunkSummaryTokens} (${chunkSummaryLimitText})`\n );\n console.log(\"Summarizing chunks...\");\n const summarizedChunks = await Promise.all(\n chunks.map(async (chunk) =>\n createChatCompletion({\n model,",
"score": 20.713856032768884
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " .map(\n (chunk) =>\n `=== SUMMARIZED CHUNK (${countTokens(\n chunk\n )} tokens) ===\\n\\n${chunk}\\n\\n`\n )\n .join(\"\");\n // console.log(`Summary:\\n\\n${summary}\\n`);\n console.log(`Summary tokens: ${countTokens(summary)}`);\n await browser.close();",
"score": 20.512508492605235
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " chunks.push(lastChunk);\n // console.log(\n // chunks\n // .map((chunk) => `CHUNK (${countTokens(chunk)}):\\n\\n${chunk}\\n\\n`)\n // .join(\"\")\n // );\n console.log(\n `Total chunks: ${chunks.length} (${Math.round(\n markdownTokens / chunks.length\n )} tokens per chunk)`",
"score": 19.14894565595562
}
] | typescript | makeDecision([
...eventsToSummarize,
{ |
import { google } from "googleapis";
import puppeteer from "puppeteer";
import TurndownService from "turndown";
import { messageBuilder } from "../../message";
import { Model, contextWindowSize, createChatCompletion } from "../../openai";
import { model } from "../../parameters";
import {
AVG_CHARACTERS_PER_TOKEN,
AVG_WORDS_PER_TOKEN,
countTokens,
} from "../../util";
import { defineModule } from "../define-module";
export default defineModule({
name: "web",
}).with({
actions: {
searchWeb: {
description: "Search the web.",
parameters: {
searchString: {
description: "The string to search for",
},
},
async execute({
parameters: { searchString },
context: { agentId },
sendMessage,
}) {
const items = await getSearchResults(searchString);
if (!items) {
return sendMessage(
messageBuilder.ok(agentId, "Search returned no results.")
);
}
sendMessage(
messageBuilder.ok(
agentId,
`Search results:\n\n${items
.map((item) => `- Title: "${item.title}"\n URL: ${item.link}`)
.join("\n\n")}`
)
);
},
},
readPage: {
description: "View a markdown summary of a web page.",
parameters: {
url: {
description: "The URL of the web page to read",
},
},
async execute({
parameters: { url },
context: { agentId },
sendMessage,
}) {
try {
const maxCompletionTokens = contextWindowSize[model] / 4;
// console.log({ maxCompletionTokens });
const pageSummary = await getPageSummary(
model,
maxCompletionTokens,
url
);
sendMessage(
messageBuilder.ok(
agentId,
`Here is a summarized markdown version of the page, in a series of summarized chunks:\n\n${pageSummary}`
)
);
} catch (e: any) {
sendMessage(
messageBuilder.error(
agentId,
`Error extracting content from ${url}: ${e.message}`
)
);
}
},
},
},
});
export async function getSearchResults(searchString: string) {
const { data } = await google.customsearch("v1").cse.list({
q: searchString,
cx: process.env.GOOGLE_SEARCH_ENGINE_ID,
key: process.env.GOOGLE_API_KEY,
});
return data.items;
}
export async function getPageSummary(
| model: Model,
maxSummaryTokens: number,
url: string
) { |
const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9);
console.log("Initializing...");
const browser = await puppeteer.launch();
const page = await browser.newPage();
const turndownService = new TurndownService().addRule(
"remove-extraneous-tags",
{
filter: ["style", "script", "img"],
replacement: () => "",
}
);
console.log(`Reading page at ${url}...`);
await page.goto(url);
const htmlContent = await page.content();
// console.log(htmlContent);
console.log(`HTML tokens: ${countTokens(htmlContent)}`);
turndownService.remove(["style", "script"]);
const markdownContent = turndownService
.turndown(htmlContent)
.replace(/\\_/g, "_");
const markdownTokens = countTokens(markdownContent);
console.log(`Markdown tokens: ${markdownTokens}`);
const chunks: string[] = [];
let currentChunkLines: string[] = [];
let currentChunkTokens = 0;
for (const line of markdownContent.split("\n")) {
const lineTokens = countTokens(line);
if (currentChunkTokens + lineTokens > maxCompletionTokens) {
chunks.push(currentChunkLines.join("\n"));
currentChunkLines = [];
currentChunkTokens = 0;
}
currentChunkLines.push(line);
currentChunkTokens += lineTokens;
}
let lastChunk = currentChunkLines.join("\n");
if (countTokens(lastChunk) > maxCompletionTokens) {
const characterLimit = Math.round(
maxCompletionTokens * AVG_CHARACTERS_PER_TOKEN
);
console.log(
`Truncating final chunk at ${characterLimit} characters:\n\n${lastChunk}`
);
lastChunk = lastChunk.substring(0, characterLimit);
}
chunks.push(lastChunk);
// console.log(
// chunks
// .map((chunk) => `CHUNK (${countTokens(chunk)}):\n\n${chunk}\n\n`)
// .join("")
// );
console.log(
`Total chunks: ${chunks.length} (${Math.round(
markdownTokens / chunks.length
)} tokens per chunk)`
);
const maxChunkSummaryTokens = Math.round(maxSummaryTokens / chunks.length);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryWords = Math.round(
maxChunkSummaryTokens * AVG_WORDS_PER_TOKEN
);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const maxChunkSummaryCharacters = Math.round(
maxChunkSummaryTokens * AVG_CHARACTERS_PER_TOKEN
);
// const summaryLimitText = `${maxChunkSummaryWords} words`;
const chunkSummaryLimitText = `${maxChunkSummaryCharacters} characters`;
console.log(
`Max tokens per chunk summary: ${maxChunkSummaryTokens} (${chunkSummaryLimitText})`
);
console.log("Summarizing chunks...");
const summarizedChunks = await Promise.all(
chunks.map(async (chunk) =>
createChatCompletion({
model,
messages: [
{
role: "user",
content: `Modify the following markdown excerpt only as much as necessary to bring it under a maximum of ${chunkSummaryLimitText}, preserving the most essential information. In particular, try to preserve links (example: \`[my special link](https://foo.bar/baz/)\`). Write this in the same voice as the original text; do not speak in the voice of someone who is describing it to someone else. For instance, don't use phrases like "The article talks about...". Excerpt to summarize follows:\n\n=============\n\n${chunk}`,
},
],
})
)
);
const summary = summarizedChunks
.map(
(chunk) =>
`=== SUMMARIZED CHUNK (${countTokens(
chunk
)} tokens) ===\n\n${chunk}\n\n`
)
.join("");
// console.log(`Summary:\n\n${summary}\n`);
console.log(`Summary tokens: ${countTokens(summary)}`);
await browser.close();
return summary;
}
| src/module/definitions/web.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/agent.ts",
"retrieved_chunk": " if (process.env.AGENT_DELAY) {\n await sleep(parseInt(process.env.AGENT_DELAY));\n }\n }\n }\n}",
"score": 27.648929633629304
},
{
"filename": "src/openai.ts",
"retrieved_chunk": "}\n// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded\nconst openai = memoize(() => {\n const apiKey = process.env.OPENAI_API_KEY;\n if (!apiKey) throw Error(\"OPENAI_API_KEY is not configured!\");\n const configuration = new Configuration({\n apiKey: process.env.OPENAI_API_KEY,\n });\n return new OpenAIApi(configuration);\n});",
"score": 22.715141488867978
},
{
"filename": "src/console.ts",
"retrieved_chunk": "import readline from \"readline\";\nimport { messageBuilder } from \"./message\";\nimport { MessageBus } from \"./message-bus\";\nconst AGENT_ID = \"0\";\nconst rl = readline.createInterface({\n input: process.stdin,\n output: process.stdout,\n prompt: \"$ \",\n});\nexport function startConsole(agentIds: string[], messageBus: MessageBus) {",
"score": 14.208187304400562
},
{
"filename": "src/parameters.ts",
"retrieved_chunk": "import { GPT_3_5_TURBO, GPT_4, Model } from \"./openai\";\nconst args = process.argv.slice(2); // Remove the first two elements (Node.js executable and script path)\nexport const numberOfAgents = args.length > 0 ? parseInt(args[0]) : 1;\nconsole.log(`Number of agents: ${numberOfAgents}`);\nconst modelText = args.length > 1 ? args[1] : \"gpt-3.5-turbo\";\nexport let model: Model;\nswitch (modelText) {\n case GPT_3_5_TURBO:\n case GPT_4:\n model = modelText;",
"score": 14.051280422385346
},
{
"filename": "src/parameters.ts",
"retrieved_chunk": " break;\n default:\n throw Error(`Unrecognized OpenAI model: '${modelText}'`);\n}\nconsole.log(`Model: ${model}`);",
"score": 10.953252573585921
}
] | typescript | model: Model,
maxSummaryTokens: number,
url: string
) { |
import { CODE_BLOCK_DELIMITER } from "./message";
import { ActionDefinition } from "./module/action-definition";
import { getUsageText } from "./module/util";
import { MULTILINE_DELIMITER } from "./util";
type ParseResult =
| {
type: "success";
action: Action;
}
| { type: "error"; message: string };
export interface Action {
actionDef: ActionDefinition;
thoughts?: string;
parameters: Record<string, string>;
}
export default function parseAction(
actionDictionary: Map<string, ActionDefinition>,
text: string
): ParseResult {
try {
text = text.trim();
if (!/^\S+(?=\n|$)/.test(text.split("\n")[0])) {
return {
type: "error",
message: `
Your action could not be parsed. Remember to always format your entire response as an action, like this:
${CODE_BLOCK_DELIMITER}
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
`.trim(),
};
}
text = `name: ${text}`;
const jsonText =
"{" +
text
.split(MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => {
if (i % 2 === 0) return part;
return JSON.stringify(part) + "\n";
})
.join("")
.split("\n")
.filter(Boolean)
.map((line) => {
const colonIndex = line.indexOf(":");
if (colonIndex < 0)
throw new Error(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`${MULTILINE_DELIMITER}\`)?`
);
const key = line.substring(0, colonIndex).trim();
let value = line.substring(colonIndex + 1).trim();
if (!value.startsWith('"') || !value.endsWith('"'))
value = JSON.stringify(value);
return `"${key}": ${value}`;
})
.join(",") +
"}";
const { name, thoughts, ...parameters } = JSON.parse(jsonText);
const actionDef = actionDictionary.get(name);
if (!actionDef)
return {
type: "error",
message: `Unknown action \`${name}\`. Please refer to the list of available actions given in the introductory message.`,
};
const missingProps = Object.entries(actionDef.parameters)
.filter(
([name, parameterDef]) =>
!parameterDef.optional && !(name in parameters)
)
.map(([name]) => name);
if (missingProps.length) {
return {
type: "error",
message: `Missing required parameter${
missingProps.length > 1 ? "s" : ""
| } ${missingProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
}; |
}
const extraProps = Object.keys(parameters).filter(
(p) => !(p in actionDef.parameters)
);
if (extraProps.length) {
return {
type: "error",
message: `Extraneous parameter${
extraProps.length > 1 ? "s" : ""
} ${extraProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
return { type: "success", action: { actionDef, thoughts, parameters } };
} catch (e: any) {
return {
type: "error",
message: e.message,
};
}
}
| src/parse-action.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/util.ts",
"retrieved_chunk": "import { CODE_BLOCK_DELIMITER } from \"../message\";\nimport { ActionDefinition } from \"./action-definition\";\nexport function getUsageText(actionDef: ActionDefinition): string {\n return `Usage:\n${CODE_BLOCK_DELIMITER}\n${actionDef.name}\nthoughts: <reasoning behind this action> (optional)${Object.entries(\n actionDef.parameters\n )\n .map(([name, { description }]) =>",
"score": 27.699211936396477
},
{
"filename": "src/module/util.ts",
"retrieved_chunk": " name === \"name\"\n ? undefined\n : `\\n${name}: <${description.toLowerCase()}>${\n actionDef.parameters[name].optional ? \" (optional)\" : \"\"\n }`\n )\n .filter(Boolean)\n .join(\"\")}\n${CODE_BLOCK_DELIMITER}`;\n}",
"score": 24.152326892714342
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "`.trim()\n );\n});\ntest(\"missing required parameter\", () => {\n expect(assertInvalid(\"sendMessage\\ntargetAgentId: 0\")).toBe(\n `Missing required parameter \\`message\\`. ${getUsageText(\n messaging.actions.sendMessage\n )}`\n );\n});",
"score": 22.91040398158296
},
{
"filename": "src/module/define-module.ts",
"retrieved_chunk": " name,\n parameters: mapValues(parameters, (parameter) => ({\n optional: false,\n ...parameter,\n })),\n ...definition,\n },\n ]\n )\n ) as any,",
"score": 21.331048691379067
},
{
"filename": "src/module/module-manager.ts",
"retrieved_chunk": " moduleDefinitions: ModuleDefinition[]\n ) {\n this.modules = moduleDefinitions.map(\n (moduleDef) => new ModuleInstance(this, moduleDef)\n );\n this.actions = moduleDefinitions\n .flatMap((module) => Object.values(module.actions))\n .reduce(\n (map, actionDef) => (map.set(actionDef.name, actionDef), map),\n new Map()",
"score": 18.936809613695914
}
] | typescript | } ${missingProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
}; |
import { Event } from ".";
import makeDecision, { toOpenAiMessage } from "../make-decision";
import { messageBuilder } from "../message";
import { ModuleManager } from "../module/module-manager";
import { Store } from "../store";
import {
AVG_WORDS_PER_TOKEN,
agentName,
countTokens as countTokensInText,
messageSourceName,
} from "../util";
export class Memory {
private firstRetrieval = true;
constructor(
private agentId: string,
private moduleManager: ModuleManager,
private store: Store<Event[]>,
private compressionThreshold: number
) {}
async append(event: Event): Promise<Event[]> {
this.printEvent(event);
let events = await this.retrieve();
if (event.type === "message" && event.message.type === "ok") {
// After an "ok" message is sent, remove all errors and their antecedents from memory,
// since agents tend to repeat mistakes rather than learning from them.
events = this.removeErrors(events);
}
events.push(event);
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
return events;
}
async retrieve(): Promise<Event[]> {
const introduction = await this.getIntroduction();
const storedEvents = await this.store.get(this.key);
let events = [
introduction,
...(storedEvents || [{ type: "decision", actionText: "noop" }]),
];
if (this.firstRetrieval) {
this.firstRetrieval = false;
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
}
// events.forEach((event) => this.printEvent(event));
return events;
}
private async getIntroduction(): Promise<Event> {
const nestedEvents = await Promise.all(
this.moduleManager.modules.map | (async (module): Promise<string[]> => { |
const { name, pinnedMessage } = module.moduleDef;
if (!pinnedMessage) return [];
const content = await pinnedMessage(module.context);
if (!content) return [];
return [`--- ${name.toUpperCase()} ---\n\n${content}`];
})
);
return {
type: "message",
message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
};
}
private removeErrors(events: Event[]): Event[] {
const cleaned: Event[] = [];
for (let i = events.length - 1; i >= 0; i--) {
const event = events[i];
if (event.type === "message" && event.message.type === "error") {
const prevEvent = events[i - 1];
// console.log("REMOVING", JSON.stringify(prevEvent, null, 2));
// console.log("REMOVING", JSON.stringify(event, null, 2));
if (prevEvent.type === "decision") {
i--; // skip the previous action which generated the error
} else {
console.error("error event was not preceded by an action");
}
continue;
}
cleaned.push(event);
}
cleaned.reverse();
// console.log({ events, cleaned });
return cleaned;
}
/**
* Compress the event history when it becomes too large in order to free up the context window.
*/
private async summarize(events: Event[]): Promise<Event[]> {
if (!events.length) return [];
const cumulativeTokenCounts = this.getCumulativeTokenCounts(events);
const totalTokenCount =
cumulativeTokenCounts[cumulativeTokenCounts.length - 1];
const thresholdOverrun = totalTokenCount - this.compressionThreshold;
const truncationThreshold =
cumulativeTokenCounts[0] +
Math.max(
thresholdOverrun,
Math.floor((totalTokenCount - cumulativeTokenCounts[0]) / 2)
);
// console.log(
// `Token count: ${totalTokenCount}\nRemaining context space: ${-thresholdOverrun}`
// );
// console.log({
// compressionThreshold: this.compressionThreshold,
// truncationThreshold,
// thresholdOverrun,
// cumulativeTokenCounts,
// });
if (thresholdOverrun > 0) {
let i = 1;
// prettier-ignore
for (; i < events.length && cumulativeTokenCounts[i - 1] <= truncationThreshold; i++);
// prettier-ignore
for (; i > 0 && cumulativeTokenCounts[i - 1] > this.compressionThreshold; i--);
i = Math.max(i, 3);
const precedingTokens = cumulativeTokenCounts[i - 1];
// console.log({ truncationIndex: i, precedingTokens });
const summaryWordLimit = Math.floor(
(this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6
);
const eventsToSummarize = events.slice(0, i);
// console.log(
// `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize
// .map(countTokens)
// .reduce((sum, next) => sum + next, 0)} tokens)`
// );
const summaryContent = await makeDecision([
...eventsToSummarize,
{
type: "message",
message: messageBuilder.ok(
this.agentId,
`Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`
),
},
]);
const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\n\n${summaryContent}`;
// const summary =
// "Several events are omitted here to free up space in your context window.";
const summaryEvent: Event = {
type: "message",
message: messageBuilder.spontaneous(this.agentId, summary),
};
const summaryTokens = countTokens(summaryEvent);
const tokenSavings =
precedingTokens - summaryTokens - cumulativeTokenCounts[0];
if (tokenSavings > 0) {
// console.log(
// `Summarized events, saving ${tokenSavings} tokens:\n\n${summary}`
// );
const newEvents = [events[0], summaryEvent, ...events.slice(i)];
// const newCumulativeTokenCounts =
// this.getCumulativeTokenCounts(newEvents);
// console.log({ newCumulativeTokenCounts });
return newEvents;
}
}
return events;
}
private getCumulativeTokenCounts(events: Event[]) {
return events.reduce((counts, event) => {
const prevSum = counts.length ? counts[counts.length - 1] : 0;
counts.push(prevSum + countTokens(event));
return counts;
}, [] as number[]);
}
private get key() {
return "memory";
}
private printEvent(event: Event) {
let sourceName: string;
let targetNames: string[];
if (event.type === "message") {
const { message } = event;
sourceName = messageSourceName(message.source);
targetNames = message.targetAgentIds?.map(agentName);
} else {
sourceName = agentName(this.agentId);
targetNames = ["System"];
}
console.log(
`${sourceName} -> ${targetNames.join(", ")}:\n\n${
toOpenAiMessage(event).content
}\n\n=============\n`
);
}
}
function countTokens(event: Event) {
return countTokensInText(toOpenAiMessage(event).content);
}
| src/memory/memory.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/agent.ts",
"retrieved_chunk": " // )\n // );\n // }\n // }, heartbeatInterval);\n }\n private async takeAction(): Promise<void> {\n try {\n let events = await this.memory.retrieve();\n // Do not act again if the last event was a decision\n if (last(events)?.type === \"decision\") return;",
"score": 58.996395370102704
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " const actionText = await makeDecision(events);\n // Reassign events in case summarization occurred\n events = await this.memory.append({\n type: \"decision\",\n actionText,\n });\n const result = parseAction(this.moduleManager.actions, actionText);\n if (result.type === \"error\") {\n this.messageBus.send(messageBuilder.error(this.id, result.message));\n } else {",
"score": 49.33945943601609
},
{
"filename": "src/make-decision.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport { Event } from \"./memory\";\nimport { createChatCompletion } from \"./openai\";\nimport { model } from \"./parameters\";\nimport { messageSourceName } from \"./util\";\nexport default async function makeDecision(events: Event[]): Promise<string> {\n console.log(`Reflecting on ${events.length} events...`);\n const t0 = Date.now();\n const messages = events.map(toOpenAiMessage);\n // console.log(JSON.stringify(messages, null, 2));",
"score": 44.60661597613436
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " if (!fileExists) return undefined;\n const buffer = await readFile(path, \"utf-8\");\n return buffer.toString();\n }\n async set(key: string, value: string) {\n await this.mkdirs();\n await writeFile(this.pathFor(key), value, \"utf-8\");\n }\n async delete(key: string) {\n await this.mkdirs();",
"score": 31.05212042199936
},
{
"filename": "src/store/in-memory-store.ts",
"retrieved_chunk": "import { Store } from \".\";\nexport default class InMemoryStore implements Store<string> {\n private map = new Map<string, string>();\n async get(key: string) {\n return this.map.get(key);\n }\n async set(key: string, value: string) {\n this.map.set(key, value);\n }\n async delete(key: string) {",
"score": 29.49593848205083
}
] | typescript | (async (module): Promise<string[]> => { |
import { CODE_BLOCK_DELIMITER } from "./message";
import { ActionDefinition } from "./module/action-definition";
import { getUsageText } from "./module/util";
import { MULTILINE_DELIMITER } from "./util";
type ParseResult =
| {
type: "success";
action: Action;
}
| { type: "error"; message: string };
export interface Action {
actionDef: ActionDefinition;
thoughts?: string;
parameters: Record<string, string>;
}
export default function parseAction(
actionDictionary: Map<string, ActionDefinition>,
text: string
): ParseResult {
try {
text = text.trim();
if (!/^\S+(?=\n|$)/.test(text.split("\n")[0])) {
return {
type: "error",
message: `
Your action could not be parsed. Remember to always format your entire response as an action, like this:
${CODE_BLOCK_DELIMITER}
<action name>
<arg 1 name>: <prop value>
<arg 2 name>: <prop value>
...
${CODE_BLOCK_DELIMITER}
`.trim(),
};
}
text = `name: ${text}`;
const jsonText =
"{" +
text
.split | (MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => { |
if (i % 2 === 0) return part;
return JSON.stringify(part) + "\n";
})
.join("")
.split("\n")
.filter(Boolean)
.map((line) => {
const colonIndex = line.indexOf(":");
if (colonIndex < 0)
throw new Error(
`Your action could not be parsed. Did you fail to wrap the entirety of a multi-line parameter value with the multi-line delimiter (\`${MULTILINE_DELIMITER}\`)?`
);
const key = line.substring(0, colonIndex).trim();
let value = line.substring(colonIndex + 1).trim();
if (!value.startsWith('"') || !value.endsWith('"'))
value = JSON.stringify(value);
return `"${key}": ${value}`;
})
.join(",") +
"}";
const { name, thoughts, ...parameters } = JSON.parse(jsonText);
const actionDef = actionDictionary.get(name);
if (!actionDef)
return {
type: "error",
message: `Unknown action \`${name}\`. Please refer to the list of available actions given in the introductory message.`,
};
const missingProps = Object.entries(actionDef.parameters)
.filter(
([name, parameterDef]) =>
!parameterDef.optional && !(name in parameters)
)
.map(([name]) => name);
if (missingProps.length) {
return {
type: "error",
message: `Missing required parameter${
missingProps.length > 1 ? "s" : ""
} ${missingProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
const extraProps = Object.keys(parameters).filter(
(p) => !(p in actionDef.parameters)
);
if (extraProps.length) {
return {
type: "error",
message: `Extraneous parameter${
extraProps.length > 1 ? "s" : ""
} ${extraProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
};
}
return { type: "success", action: { actionDef, thoughts, parameters } };
} catch (e: any) {
return {
type: "error",
message: e.message,
};
}
}
| src/parse-action.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/util.ts",
"retrieved_chunk": " return `${agentId === \"0\" ? \"Control\" : `Agent ${agentId}`}`;\n}\nexport const MULTILINE_DELIMITER = `% ${\"ff9d7713-0bb0-40d4-823c-5a66de48761b\"}`;\nexport const AVG_WORDS_PER_TOKEN = 0.75;\nexport const AVG_CHARACTERS_PER_TOKEN = 4;\nexport function countTokens(text: string) {\n return encode(text).length;\n}",
"score": 15.684863424438127
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": "export default defineModule<Store<Goal[]>>({\n name: \"goals\",\n createState: ({ agentId }) => new JsonStore(new FileStore([agentId])),\n}).with({\n async pinnedMessage({ state }) {\n const goals = (await state.get(KEY)) || [];\n const currentGloals = goals.length\n ? `This is your current goal list:\\n\\n${goals\n .map(\n ({ text, complete }, index) =>",
"score": 13.44040600290754
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " message: 'hello, \"control\"',\n });\n });\n});\n// =============================================================================\nfunction assertValid(text: string): Action {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"error\") throw Error(`Parse failed: ${result.message}`);\n return result.action;\n}",
"score": 12.550386205814727
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "function assertInvalid(text: string): string {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"success\")\n throw Error(\n `Parse succeeded when it should've failed: ${JSON.stringify(\n result.action,\n null,\n 2\n )}`\n );",
"score": 12.151031239214161
},
{
"filename": "src/module/module-manager.ts",
"retrieved_chunk": " moduleDefinitions: ModuleDefinition[]\n ) {\n this.modules = moduleDefinitions.map(\n (moduleDef) => new ModuleInstance(this, moduleDef)\n );\n this.actions = moduleDefinitions\n .flatMap((module) => Object.values(module.actions))\n .reduce(\n (map, actionDef) => (map.set(actionDef.name, actionDef), map),\n new Map()",
"score": 10.088887775344691
}
] | typescript | (MULTILINE_DELIMITER)
.map((part) => part.trim())
.map((part, i) => { |
import { Event } from ".";
import makeDecision, { toOpenAiMessage } from "../make-decision";
import { messageBuilder } from "../message";
import { ModuleManager } from "../module/module-manager";
import { Store } from "../store";
import {
AVG_WORDS_PER_TOKEN,
agentName,
countTokens as countTokensInText,
messageSourceName,
} from "../util";
export class Memory {
private firstRetrieval = true;
constructor(
private agentId: string,
private moduleManager: ModuleManager,
private store: Store<Event[]>,
private compressionThreshold: number
) {}
async append(event: Event): Promise<Event[]> {
this.printEvent(event);
let events = await this.retrieve();
if (event.type === "message" && event.message.type === "ok") {
// After an "ok" message is sent, remove all errors and their antecedents from memory,
// since agents tend to repeat mistakes rather than learning from them.
events = this.removeErrors(events);
}
events.push(event);
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
return events;
}
async retrieve(): Promise<Event[]> {
const introduction = await this.getIntroduction();
const storedEvents = await this.store.get(this.key);
let events = [
introduction,
...(storedEvents || [{ type: "decision", actionText: "noop" }]),
];
if (this.firstRetrieval) {
this.firstRetrieval = false;
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
}
// events.forEach((event) => this.printEvent(event));
return events;
}
private async getIntroduction(): Promise<Event> {
const nestedEvents = await Promise.all(
this.moduleManager.modules.map(async (module): Promise<string[]> => {
const { name, pinnedMessage } = module.moduleDef;
if (!pinnedMessage) return [];
const content = await pinnedMessage(module.context);
if (!content) return [];
return [`--- ${name.toUpperCase()} ---\n\n${content}`];
})
);
return {
type: "message",
| message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
}; |
}
private removeErrors(events: Event[]): Event[] {
const cleaned: Event[] = [];
for (let i = events.length - 1; i >= 0; i--) {
const event = events[i];
if (event.type === "message" && event.message.type === "error") {
const prevEvent = events[i - 1];
// console.log("REMOVING", JSON.stringify(prevEvent, null, 2));
// console.log("REMOVING", JSON.stringify(event, null, 2));
if (prevEvent.type === "decision") {
i--; // skip the previous action which generated the error
} else {
console.error("error event was not preceded by an action");
}
continue;
}
cleaned.push(event);
}
cleaned.reverse();
// console.log({ events, cleaned });
return cleaned;
}
/**
* Compress the event history when it becomes too large in order to free up the context window.
*/
private async summarize(events: Event[]): Promise<Event[]> {
if (!events.length) return [];
const cumulativeTokenCounts = this.getCumulativeTokenCounts(events);
const totalTokenCount =
cumulativeTokenCounts[cumulativeTokenCounts.length - 1];
const thresholdOverrun = totalTokenCount - this.compressionThreshold;
const truncationThreshold =
cumulativeTokenCounts[0] +
Math.max(
thresholdOverrun,
Math.floor((totalTokenCount - cumulativeTokenCounts[0]) / 2)
);
// console.log(
// `Token count: ${totalTokenCount}\nRemaining context space: ${-thresholdOverrun}`
// );
// console.log({
// compressionThreshold: this.compressionThreshold,
// truncationThreshold,
// thresholdOverrun,
// cumulativeTokenCounts,
// });
if (thresholdOverrun > 0) {
let i = 1;
// prettier-ignore
for (; i < events.length && cumulativeTokenCounts[i - 1] <= truncationThreshold; i++);
// prettier-ignore
for (; i > 0 && cumulativeTokenCounts[i - 1] > this.compressionThreshold; i--);
i = Math.max(i, 3);
const precedingTokens = cumulativeTokenCounts[i - 1];
// console.log({ truncationIndex: i, precedingTokens });
const summaryWordLimit = Math.floor(
(this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6
);
const eventsToSummarize = events.slice(0, i);
// console.log(
// `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize
// .map(countTokens)
// .reduce((sum, next) => sum + next, 0)} tokens)`
// );
const summaryContent = await makeDecision([
...eventsToSummarize,
{
type: "message",
message: messageBuilder.ok(
this.agentId,
`Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`
),
},
]);
const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\n\n${summaryContent}`;
// const summary =
// "Several events are omitted here to free up space in your context window.";
const summaryEvent: Event = {
type: "message",
message: messageBuilder.spontaneous(this.agentId, summary),
};
const summaryTokens = countTokens(summaryEvent);
const tokenSavings =
precedingTokens - summaryTokens - cumulativeTokenCounts[0];
if (tokenSavings > 0) {
// console.log(
// `Summarized events, saving ${tokenSavings} tokens:\n\n${summary}`
// );
const newEvents = [events[0], summaryEvent, ...events.slice(i)];
// const newCumulativeTokenCounts =
// this.getCumulativeTokenCounts(newEvents);
// console.log({ newCumulativeTokenCounts });
return newEvents;
}
}
return events;
}
private getCumulativeTokenCounts(events: Event[]) {
return events.reduce((counts, event) => {
const prevSum = counts.length ? counts[counts.length - 1] : 0;
counts.push(prevSum + countTokens(event));
return counts;
}, [] as number[]);
}
private get key() {
return "memory";
}
private printEvent(event: Event) {
let sourceName: string;
let targetNames: string[];
if (event.type === "message") {
const { message } = event;
sourceName = messageSourceName(message.source);
targetNames = message.targetAgentIds?.map(agentName);
} else {
sourceName = agentName(this.agentId);
targetNames = ["System"];
}
console.log(
`${sourceName} -> ${targetNames.join(", ")}:\n\n${
toOpenAiMessage(event).content
}\n\n=============\n`
);
}
}
function countTokens(event: Event) {
return countTokensInText(toOpenAiMessage(event).content);
}
| src/memory/memory.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " return sendMessage(\n messageBuilder.ok(agentId, \"Search returned no results.\")\n );\n }\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Search results:\\n\\n${items\n .map((item) => `- Title: \"${item.title}\"\\n URL: ${item.link}`)\n .join(\"\\n\\n\")}`",
"score": 23.52738205933891
},
{
"filename": "src/make-decision.ts",
"retrieved_chunk": " header = \"\";\n break;\n case \"agentToAgent\":\n header = `--- MESSAGE FROM ${messageSourceName(\n source\n ).toUpperCase()} ---\\n\\n`;\n break;\n case \"error\":\n header = \"--- ERROR ---\\n\\n\";\n break;",
"score": 21.717841557087358
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " sendMessage(\n messageBuilder.ok(\n agentId,\n `These are the agents in the system:\\n\\n${allAgentIds\n .map((id) => `${agentName(id)} [agentId=${id}]`)\n .join(\"\\n\")}`\n )\n );\n },\n },",
"score": 20.70001102625386
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " messageBuilder.ok(agentId, `Content of \"${title}\":\\n\\n${content}`)\n );\n } else {\n sendMessage(\n messageBuilder.error(agentId, `Note \"${title}\" not found.`)\n );\n }\n },\n },\n deleteNote: {",
"score": 19.701712532250227
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " .map(\n (chunk) =>\n `=== SUMMARIZED CHUNK (${countTokens(\n chunk\n )} tokens) ===\\n\\n${chunk}\\n\\n`\n )\n .join(\"\");\n // console.log(`Summary:\\n\\n${summary}\\n`);\n console.log(`Summary tokens: ${countTokens(summary)}`);\n await browser.close();",
"score": 19.35806382451402
}
] | typescript | message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
}; |
import { ChatCompletionRequestMessage } from "openai";
import { Event } from "./memory";
import { createChatCompletion } from "./openai";
import { model } from "./parameters";
import { messageSourceName } from "./util";
export default async function makeDecision(events: Event[]): Promise<string> {
console.log(`Reflecting on ${events.length} events...`);
const t0 = Date.now();
const messages = events.map(toOpenAiMessage);
// console.log(JSON.stringify(messages, null, 2));
const responseContent = await createChatCompletion({
model,
messages,
temperature: 0.0,
});
console.log(
`Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`
);
return responseContent;
}
// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded
export function toOpenAiMessage(event: Event): ChatCompletionRequestMessage {
switch (event.type) {
case "message": {
const { type: messageType, source, content } = event.message;
const role = source.type === "system" ? "system" : "user";
let header: string;
switch (messageType) {
case "spontaneous":
case "ok":
header = "";
break;
case "agentToAgent":
header = `--- MESSAGE FROM ${messageSourceName(
source
).toUpperCase()} ---\n\n`;
break;
case "error":
header = "--- ERROR ---\n\n";
break;
}
return {
role,
content: `${header}${content}`,
};
}
case "decision":
return {
role: "assistant",
| content: event.actionText,
}; |
}
}
| src/make-decision.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return countTokensInText(toOpenAiMessage(event).content);\n}",
"score": 16.733223784929642
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const { name, pinnedMessage } = module.moduleDef;\n if (!pinnedMessage) return [];\n const content = await pinnedMessage(module.context);\n if (!content) return [];\n return [`--- ${name.toUpperCase()} ---\\n\\n${content}`];\n })\n );\n return {\n type: \"message\",\n message: messageBuilder.spontaneous(",
"score": 13.224907612701074
},
{
"filename": "src/message.ts",
"retrieved_chunk": "}\nfunction singleTargetSystemMessage(\n agentId: string,\n content: string\n): TypelessMessage {\n return {\n source: systemSource,\n targetAgentIds: [agentId],\n content,\n };",
"score": 12.764486273986533
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " const actionText = await makeDecision(events);\n // Reassign events in case summarization occurred\n events = await this.memory.append({\n type: \"decision\",\n actionText,\n });\n const result = parseAction(this.moduleManager.actions, actionText);\n if (result.type === \"error\") {\n this.messageBus.send(messageBuilder.error(this.id, result.message));\n } else {",
"score": 12.255092769916626
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " targetNames = [\"System\"];\n }\n console.log(\n `${sourceName} -> ${targetNames.join(\", \")}:\\n\\n${\n toOpenAiMessage(event).content\n }\\n\\n=============\\n`\n );\n }\n}\nfunction countTokens(event: Event) {",
"score": 11.75991680259613
}
] | typescript | content: event.actionText,
}; |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
| let events = await this.memory.retrieve(); |
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 21.850427631522493
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 21.139749263186456
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 18.749742943721444
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " {\n type: \"message\",\n message: messageBuilder.ok(\n this.agentId,\n `Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`\n ),\n },\n ]);\n const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\\n\\n${summaryContent}`;\n // const summary =",
"score": 14.870383714010728
},
{
"filename": "src/task-queue.ts",
"retrieved_chunk": " if (this.running) {\n await this.running;\n }\n }\n private async runNext() {\n if (this.running) return;\n const task = this.tasks.shift();\n if (!task) return;\n try {\n await (this.running = task());",
"score": 13.96036670686691
}
] | typescript | let events = await this.memory.retrieve(); |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
| if (last(events)?.type === "decision") return; |
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 34.491428873292996
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 28.122339281191486
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 25.098316452561683
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const prevEvent = events[i - 1];\n // console.log(\"REMOVING\", JSON.stringify(prevEvent, null, 2));\n // console.log(\"REMOVING\", JSON.stringify(event, null, 2));\n if (prevEvent.type === \"decision\") {\n i--; // skip the previous action which generated the error\n } else {\n console.error(\"error event was not preceded by an action\");\n }\n continue;\n }",
"score": 24.173885630585698
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.agentId,\n nestedEvents.flat().join(\"\\n\\n\")\n ),\n };\n }\n private removeErrors(events: Event[]): Event[] {\n const cleaned: Event[] = [];\n for (let i = events.length - 1; i >= 0; i--) {\n const event = events[i];\n if (event.type === \"message\" && event.message.type === \"error\") {",
"score": 22.993831593815376
}
] | typescript | if (last(events)?.type === "decision") return; |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await | makeDecision(events); |
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 45.107259816256956
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 34.57120116980217
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 32.24619844725737
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.agentId,\n nestedEvents.flat().join(\"\\n\\n\")\n ),\n };\n }\n private removeErrors(events: Event[]): Event[] {\n const cleaned: Event[] = [];\n for (let i = events.length - 1; i >= 0; i--) {\n const event = events[i];\n if (event.type === \"message\" && event.message.type === \"error\") {",
"score": 27.806081593196367
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const prevEvent = events[i - 1];\n // console.log(\"REMOVING\", JSON.stringify(prevEvent, null, 2));\n // console.log(\"REMOVING\", JSON.stringify(event, null, 2));\n if (prevEvent.type === \"decision\") {\n i--; // skip the previous action which generated the error\n } else {\n console.error(\"error event was not preceded by an action\");\n }\n continue;\n }",
"score": 26.716835234725245
}
] | typescript | makeDecision(events); |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus | .send(messageBuilder.error(this.id, result.message)); |
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 46.70946393943647
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " message: 'hello, \"control\"',\n });\n });\n});\n// =============================================================================\nfunction assertValid(text: string): Action {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"error\") throw Error(`Parse failed: ${result.message}`);\n return result.action;\n}",
"score": 43.44983544117401
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "function assertInvalid(text: string): string {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"success\")\n throw Error(\n `Parse succeeded when it should've failed: ${JSON.stringify(\n result.action,\n null,\n 2\n )}`\n );",
"score": 35.19182887978195
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 34.519524162844164
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 30.83975399823266
}
] | typescript | .send(messageBuilder.error(this.id, result.message)); |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send(messageBuilder.error(this.id, result.message));
} else {
| await this.actionHandler.handle(this.id, result.action); |
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " message: 'hello, \"control\"',\n });\n });\n});\n// =============================================================================\nfunction assertValid(text: string): Action {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"error\") throw Error(`Parse failed: ${result.message}`);\n return result.action;\n}",
"score": 52.10797043672639
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "function assertInvalid(text: string): string {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"success\")\n throw Error(\n `Parse succeeded when it should've failed: ${JSON.stringify(\n result.action,\n null,\n 2\n )}`\n );",
"score": 43.0445626290667
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 42.7726112320654
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 34.36751131606207
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 30.629737230260872
}
] | typescript | await this.actionHandler.handle(this.id, result.action); |
import dotenv from "dotenv";
import ActionHandler from "./action-handler";
import { Agent } from "./agent";
import { startConsole } from "./console";
import { InMemoryMessageBus } from "./in-memory-message-bus";
import { Event, Memory } from "./memory";
import { MessageBus } from "./message-bus";
import core from "./module/definitions/core";
import filesystem from "./module/definitions/filesystem";
import goals from "./module/definitions/goals";
import messaging from "./module/definitions/messaging";
import notes from "./module/definitions/notes";
import web from "./module/definitions/web";
import { ModuleManager } from "./module/module-manager";
import { contextWindowSize } from "./openai";
import { model, numberOfAgents } from "./parameters";
import FileStore from "./store/file-store";
import JsonStore from "./store/json-store";
import { webSocketServer } from "./web-socket-server";
dotenv.config();
const agentIds = Array.from({ length: numberOfAgents + 1 }, (_, i) => `${i}`);
const messageBus: MessageBus = new InMemoryMessageBus();
main();
async function main() {
startConsole(agentIds, messageBus);
webSocketServer(messageBus, 8080);
for (const id of agentIds.slice(1)) {
const moduleManager = new ModuleManager(id, agentIds, [
core,
goals,
notes,
messaging,
filesystem,
web,
]);
const actionHandler = new ActionHandler(
agentIds,
messageBus,
moduleManager
);
const store = new JsonStore<Event[]>(new FileStore([id]));
// We have to leave room for the agent's next action, which is of unknown size
const compressionThreshold = Math.round(contextWindowSize[model] * 0.75);
const memory = new Memory(id, moduleManager, store, compressionThreshold);
const agent = new Agent(
id,
memory,
messageBus,
moduleManager,
actionHandler
);
| await agent.start(); |
}
}
| src/main.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/agent.ts",
"retrieved_chunk": "const actionInterval = 1000;\n// const heartbeatInterval = 60 * 1000;\nexport class Agent {\n constructor(\n public id: string,\n private memory: Memory,\n private messageBus: MessageBus,\n private moduleManager: ModuleManager,\n private actionHandler: ActionHandler\n ) {}",
"score": 37.32689345376055
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": "export async function getPageSummary(\n model: Model,\n maxSummaryTokens: number,\n url: string\n) {\n const maxCompletionTokens = Math.round(contextWindowSize[model] * 0.9);\n console.log(\"Initializing...\");\n const browser = await puppeteer.launch();\n const page = await browser.newPage();\n const turndownService = new TurndownService().addRule(",
"score": 24.654640045382333
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " private taskQueue = new TaskQueue();\n // Start this Agent's event loop\n async start() {\n // Subscribe to messages\n this.messageBus.subscribe((message) => {\n if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))\n return;\n this.memory.append({ type: \"message\", message });\n });\n // Act on messages periodically",
"score": 24.122877662786493
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " const actionText = await makeDecision(events);\n // Reassign events in case summarization occurred\n events = await this.memory.append({\n type: \"decision\",\n actionText,\n });\n const result = parseAction(this.moduleManager.actions, actionText);\n if (result.type === \"error\") {\n this.messageBus.send(messageBuilder.error(this.id, result.message));\n } else {",
"score": 21.92129976206654
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": "} from \"../util\";\nexport class Memory {\n private firstRetrieval = true;\n constructor(\n private agentId: string,\n private moduleManager: ModuleManager,\n private store: Store<Event[]>,\n private compressionThreshold: number\n ) {}\n async append(event: Event): Promise<Event[]> {",
"score": 20.773876074690826
}
] | typescript | await agent.start(); |
import { ChatCompletionRequestMessage } from "openai";
import { Event } from "./memory";
import { createChatCompletion } from "./openai";
import { model } from "./parameters";
import { messageSourceName } from "./util";
export default async function makeDecision(events: Event[]): Promise<string> {
console.log(`Reflecting on ${events.length} events...`);
const t0 = Date.now();
const messages = events.map(toOpenAiMessage);
// console.log(JSON.stringify(messages, null, 2));
const responseContent = await createChatCompletion({
model,
messages,
temperature: 0.0,
});
console.log(
`Arrived at a decision after ${((Date.now() - t0) / 1000).toFixed(1)}s`
);
return responseContent;
}
// lazy load to avoid accessing OPENAI_API_KEY before env has been loaded
export function toOpenAiMessage(event: Event): ChatCompletionRequestMessage {
switch (event.type) {
case "message": {
const { type: messageType, source, content } = event.message;
const role = source.type === "system" ? "system" : "user";
let header: string;
switch (messageType) {
case "spontaneous":
case "ok":
header = "";
break;
case "agentToAgent":
header = `--- MESSAGE FROM ${messageSourceName(
source
).toUpperCase()} ---\n\n`;
break;
case "error":
header = "--- ERROR ---\n\n";
break;
}
return {
role,
content: `${header}${content}`,
};
}
case "decision":
return {
role: "assistant",
content | : event.actionText,
}; |
}
}
| src/make-decision.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return countTokensInText(toOpenAiMessage(event).content);\n}",
"score": 15.37769883977047
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " const actionText = await makeDecision(events);\n // Reassign events in case summarization occurred\n events = await this.memory.append({\n type: \"decision\",\n actionText,\n });\n const result = parseAction(this.moduleManager.actions, actionText);\n if (result.type === \"error\") {\n this.messageBus.send(messageBuilder.error(this.id, result.message));\n } else {",
"score": 12.255092769916626
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " targetNames = [\"System\"];\n }\n console.log(\n `${sourceName} -> ${targetNames.join(\", \")}:\\n\\n${\n toOpenAiMessage(event).content\n }\\n\\n=============\\n`\n );\n }\n}\nfunction countTokens(event: Event) {",
"score": 11.75991680259613
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " const { name, pinnedMessage } = module.moduleDef;\n if (!pinnedMessage) return [];\n const content = await pinnedMessage(module.context);\n if (!content) return [];\n return [`--- ${name.toUpperCase()} ---\\n\\n${content}`];\n })\n );\n return {\n type: \"message\",\n message: messageBuilder.spontaneous(",
"score": 11.668590902918998
},
{
"filename": "src/message.ts",
"retrieved_chunk": "}\nfunction singleTargetSystemMessage(\n agentId: string,\n content: string\n): TypelessMessage {\n return {\n source: systemSource,\n targetAgentIds: [agentId],\n content,\n };",
"score": 11.62022067956133
}
] | typescript | : event.actionText,
}; |
import { last } from "lodash";
import ActionHandler from "./action-handler";
import makeDecision from "./make-decision";
import { Memory } from "./memory";
import { messageBuilder } from "./message";
import { MessageBus } from "./message-bus";
import { ModuleManager } from "./module/module-manager";
import parseAction from "./parse-action";
import TaskQueue from "./task-queue";
import { agentName, sleep } from "./util";
const actionInterval = 1000;
// const heartbeatInterval = 60 * 1000;
export class Agent {
constructor(
public id: string,
private memory: Memory,
private messageBus: MessageBus,
private moduleManager: ModuleManager,
private actionHandler: ActionHandler
) {}
private taskQueue = new TaskQueue();
// Start this Agent's event loop
async start() {
// Subscribe to messages
this.messageBus.subscribe((message) => {
if (message.targetAgentIds && !message.targetAgentIds.includes(this.id))
return;
this.memory.append({ type: "message", message });
});
// Act on messages periodically
this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);
// Start heartbeat
// this.taskQueue.runPeriodically(async () => {
// const messages = await this.memory.retrieve();
// const lastMessage = last(messages);
// if (lastMessage?.type === "decision") {
// this.messageBus.send(
// messageBuilder.spontaneous(
// this.id,
// "This is your regularly scheduled heartbeat message. Is there anything you need to do?"
// )
// );
// }
// }, heartbeatInterval);
}
private async takeAction(): Promise<void> {
try {
let events = await this.memory.retrieve();
// Do not act again if the last event was a decision
if (last(events)?.type === "decision") return;
const actionText = await makeDecision(events);
// Reassign events in case summarization occurred
events = await this.memory.append({
type: "decision",
actionText,
});
const result = parseAction(this.moduleManager.actions, actionText);
if (result.type === "error") {
this.messageBus.send( | messageBuilder.error(this.id, result.message)); |
} else {
await this.actionHandler.handle(this.id, result.action);
}
} catch (e) {
console.error(
`${agentName(
this.id
)} encountered the following problem while attempting to take action:`
);
console.error(e);
} finally {
if (process.env.AGENT_DELAY) {
await sleep(parseInt(process.env.AGENT_DELAY));
}
}
}
}
| src/agent.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " return events;\n }\n async retrieve(): Promise<Event[]> {\n const introduction = await this.getIntroduction();\n const storedEvents = await this.store.get(this.key);\n let events = [\n introduction,\n ...(storedEvents || [{ type: \"decision\", actionText: \"noop\" }]),\n ];\n if (this.firstRetrieval) {",
"score": 46.70946393943647
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": " message: 'hello, \"control\"',\n });\n });\n});\n// =============================================================================\nfunction assertValid(text: string): Action {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"error\") throw Error(`Parse failed: ${result.message}`);\n return result.action;\n}",
"score": 43.44983544117401
},
{
"filename": "src/parse-action.test.ts",
"retrieved_chunk": "function assertInvalid(text: string): string {\n const result = parseAction(moduleManager.actions, text);\n if (result.type === \"success\")\n throw Error(\n `Parse succeeded when it should've failed: ${JSON.stringify(\n result.action,\n null,\n 2\n )}`\n );",
"score": 35.19182887978195
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.printEvent(event);\n let events = await this.retrieve();\n if (event.type === \"message\" && event.message.type === \"ok\") {\n // After an \"ok\" message is sent, remove all errors and their antecedents from memory,\n // since agents tend to repeat mistakes rather than learning from them.\n events = this.removeErrors(events);\n }\n events.push(event);\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));",
"score": 34.519524162844164
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " this.firstRetrieval = false;\n events = await this.summarize(events);\n await this.store.set(this.key, events.slice(1));\n }\n // events.forEach((event) => this.printEvent(event));\n return events;\n }\n private async getIntroduction(): Promise<Event> {\n const nestedEvents = await Promise.all(\n this.moduleManager.modules.map(async (module): Promise<string[]> => {",
"score": 30.83975399823266
}
] | typescript | messageBuilder.error(this.id, result.message)); |
import { Event } from ".";
import makeDecision, { toOpenAiMessage } from "../make-decision";
import { messageBuilder } from "../message";
import { ModuleManager } from "../module/module-manager";
import { Store } from "../store";
import {
AVG_WORDS_PER_TOKEN,
agentName,
countTokens as countTokensInText,
messageSourceName,
} from "../util";
export class Memory {
private firstRetrieval = true;
constructor(
private agentId: string,
private moduleManager: ModuleManager,
private store: Store<Event[]>,
private compressionThreshold: number
) {}
async append(event: Event): Promise<Event[]> {
this.printEvent(event);
let events = await this.retrieve();
if (event.type === "message" && event.message.type === "ok") {
// After an "ok" message is sent, remove all errors and their antecedents from memory,
// since agents tend to repeat mistakes rather than learning from them.
events = this.removeErrors(events);
}
events.push(event);
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
return events;
}
async retrieve(): Promise<Event[]> {
const introduction = await this.getIntroduction();
const storedEvents = await this.store.get(this.key);
let events = [
introduction,
...(storedEvents || [{ type: "decision", actionText: "noop" }]),
];
if (this.firstRetrieval) {
this.firstRetrieval = false;
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
}
// events.forEach((event) => this.printEvent(event));
return events;
}
private async getIntroduction(): Promise<Event> {
const nestedEvents = await Promise.all(
this | .moduleManager.modules.map(async (module): Promise<string[]> => { |
const { name, pinnedMessage } = module.moduleDef;
if (!pinnedMessage) return [];
const content = await pinnedMessage(module.context);
if (!content) return [];
return [`--- ${name.toUpperCase()} ---\n\n${content}`];
})
);
return {
type: "message",
message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
};
}
private removeErrors(events: Event[]): Event[] {
const cleaned: Event[] = [];
for (let i = events.length - 1; i >= 0; i--) {
const event = events[i];
if (event.type === "message" && event.message.type === "error") {
const prevEvent = events[i - 1];
// console.log("REMOVING", JSON.stringify(prevEvent, null, 2));
// console.log("REMOVING", JSON.stringify(event, null, 2));
if (prevEvent.type === "decision") {
i--; // skip the previous action which generated the error
} else {
console.error("error event was not preceded by an action");
}
continue;
}
cleaned.push(event);
}
cleaned.reverse();
// console.log({ events, cleaned });
return cleaned;
}
/**
* Compress the event history when it becomes too large in order to free up the context window.
*/
private async summarize(events: Event[]): Promise<Event[]> {
if (!events.length) return [];
const cumulativeTokenCounts = this.getCumulativeTokenCounts(events);
const totalTokenCount =
cumulativeTokenCounts[cumulativeTokenCounts.length - 1];
const thresholdOverrun = totalTokenCount - this.compressionThreshold;
const truncationThreshold =
cumulativeTokenCounts[0] +
Math.max(
thresholdOverrun,
Math.floor((totalTokenCount - cumulativeTokenCounts[0]) / 2)
);
// console.log(
// `Token count: ${totalTokenCount}\nRemaining context space: ${-thresholdOverrun}`
// );
// console.log({
// compressionThreshold: this.compressionThreshold,
// truncationThreshold,
// thresholdOverrun,
// cumulativeTokenCounts,
// });
if (thresholdOverrun > 0) {
let i = 1;
// prettier-ignore
for (; i < events.length && cumulativeTokenCounts[i - 1] <= truncationThreshold; i++);
// prettier-ignore
for (; i > 0 && cumulativeTokenCounts[i - 1] > this.compressionThreshold; i--);
i = Math.max(i, 3);
const precedingTokens = cumulativeTokenCounts[i - 1];
// console.log({ truncationIndex: i, precedingTokens });
const summaryWordLimit = Math.floor(
(this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6
);
const eventsToSummarize = events.slice(0, i);
// console.log(
// `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize
// .map(countTokens)
// .reduce((sum, next) => sum + next, 0)} tokens)`
// );
const summaryContent = await makeDecision([
...eventsToSummarize,
{
type: "message",
message: messageBuilder.ok(
this.agentId,
`Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`
),
},
]);
const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\n\n${summaryContent}`;
// const summary =
// "Several events are omitted here to free up space in your context window.";
const summaryEvent: Event = {
type: "message",
message: messageBuilder.spontaneous(this.agentId, summary),
};
const summaryTokens = countTokens(summaryEvent);
const tokenSavings =
precedingTokens - summaryTokens - cumulativeTokenCounts[0];
if (tokenSavings > 0) {
// console.log(
// `Summarized events, saving ${tokenSavings} tokens:\n\n${summary}`
// );
const newEvents = [events[0], summaryEvent, ...events.slice(i)];
// const newCumulativeTokenCounts =
// this.getCumulativeTokenCounts(newEvents);
// console.log({ newCumulativeTokenCounts });
return newEvents;
}
}
return events;
}
private getCumulativeTokenCounts(events: Event[]) {
return events.reduce((counts, event) => {
const prevSum = counts.length ? counts[counts.length - 1] : 0;
counts.push(prevSum + countTokens(event));
return counts;
}, [] as number[]);
}
private get key() {
return "memory";
}
private printEvent(event: Event) {
let sourceName: string;
let targetNames: string[];
if (event.type === "message") {
const { message } = event;
sourceName = messageSourceName(message.source);
targetNames = message.targetAgentIds?.map(agentName);
} else {
sourceName = agentName(this.agentId);
targetNames = ["System"];
}
console.log(
`${sourceName} -> ${targetNames.join(", ")}:\n\n${
toOpenAiMessage(event).content
}\n\n=============\n`
);
}
}
function countTokens(event: Event) {
return countTokensInText(toOpenAiMessage(event).content);
}
| src/memory/memory.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/agent.ts",
"retrieved_chunk": " // )\n // );\n // }\n // }, heartbeatInterval);\n }\n private async takeAction(): Promise<void> {\n try {\n let events = await this.memory.retrieve();\n // Do not act again if the last event was a decision\n if (last(events)?.type === \"decision\") return;",
"score": 58.996395370102704
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " const actionText = await makeDecision(events);\n // Reassign events in case summarization occurred\n events = await this.memory.append({\n type: \"decision\",\n actionText,\n });\n const result = parseAction(this.moduleManager.actions, actionText);\n if (result.type === \"error\") {\n this.messageBus.send(messageBuilder.error(this.id, result.message));\n } else {",
"score": 49.33945943601609
},
{
"filename": "src/make-decision.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport { Event } from \"./memory\";\nimport { createChatCompletion } from \"./openai\";\nimport { model } from \"./parameters\";\nimport { messageSourceName } from \"./util\";\nexport default async function makeDecision(events: Event[]): Promise<string> {\n console.log(`Reflecting on ${events.length} events...`);\n const t0 = Date.now();\n const messages = events.map(toOpenAiMessage);\n // console.log(JSON.stringify(messages, null, 2));",
"score": 44.60661597613436
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " if (!fileExists) return undefined;\n const buffer = await readFile(path, \"utf-8\");\n return buffer.toString();\n }\n async set(key: string, value: string) {\n await this.mkdirs();\n await writeFile(this.pathFor(key), value, \"utf-8\");\n }\n async delete(key: string) {\n await this.mkdirs();",
"score": 31.05212042199936
},
{
"filename": "src/store/in-memory-store.ts",
"retrieved_chunk": "import { Store } from \".\";\nexport default class InMemoryStore implements Store<string> {\n private map = new Map<string, string>();\n async get(key: string) {\n return this.map.get(key);\n }\n async set(key: string, value: string) {\n this.map.set(key, value);\n }\n async delete(key: string) {",
"score": 29.49593848205083
}
] | typescript | .moduleManager.modules.map(async (module): Promise<string[]> => { |
import { Event } from ".";
import makeDecision, { toOpenAiMessage } from "../make-decision";
import { messageBuilder } from "../message";
import { ModuleManager } from "../module/module-manager";
import { Store } from "../store";
import {
AVG_WORDS_PER_TOKEN,
agentName,
countTokens as countTokensInText,
messageSourceName,
} from "../util";
export class Memory {
private firstRetrieval = true;
constructor(
private agentId: string,
private moduleManager: ModuleManager,
private store: Store<Event[]>,
private compressionThreshold: number
) {}
async append(event: Event): Promise<Event[]> {
this.printEvent(event);
let events = await this.retrieve();
if (event.type === "message" && event.message.type === "ok") {
// After an "ok" message is sent, remove all errors and their antecedents from memory,
// since agents tend to repeat mistakes rather than learning from them.
events = this.removeErrors(events);
}
events.push(event);
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
return events;
}
async retrieve(): Promise<Event[]> {
const introduction = await this.getIntroduction();
const storedEvents = await this.store.get(this.key);
let events = [
introduction,
...(storedEvents || [{ type: "decision", actionText: "noop" }]),
];
if (this.firstRetrieval) {
this.firstRetrieval = false;
events = await this.summarize(events);
await this.store.set(this.key, events.slice(1));
}
// events.forEach((event) => this.printEvent(event));
return events;
}
private async getIntroduction(): Promise<Event> {
const nestedEvents = await Promise.all(
this.moduleManager.modules.map(async ( | module): Promise<string[]> => { |
const { name, pinnedMessage } = module.moduleDef;
if (!pinnedMessage) return [];
const content = await pinnedMessage(module.context);
if (!content) return [];
return [`--- ${name.toUpperCase()} ---\n\n${content}`];
})
);
return {
type: "message",
message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
};
}
private removeErrors(events: Event[]): Event[] {
const cleaned: Event[] = [];
for (let i = events.length - 1; i >= 0; i--) {
const event = events[i];
if (event.type === "message" && event.message.type === "error") {
const prevEvent = events[i - 1];
// console.log("REMOVING", JSON.stringify(prevEvent, null, 2));
// console.log("REMOVING", JSON.stringify(event, null, 2));
if (prevEvent.type === "decision") {
i--; // skip the previous action which generated the error
} else {
console.error("error event was not preceded by an action");
}
continue;
}
cleaned.push(event);
}
cleaned.reverse();
// console.log({ events, cleaned });
return cleaned;
}
/**
* Compress the event history when it becomes too large in order to free up the context window.
*/
private async summarize(events: Event[]): Promise<Event[]> {
if (!events.length) return [];
const cumulativeTokenCounts = this.getCumulativeTokenCounts(events);
const totalTokenCount =
cumulativeTokenCounts[cumulativeTokenCounts.length - 1];
const thresholdOverrun = totalTokenCount - this.compressionThreshold;
const truncationThreshold =
cumulativeTokenCounts[0] +
Math.max(
thresholdOverrun,
Math.floor((totalTokenCount - cumulativeTokenCounts[0]) / 2)
);
// console.log(
// `Token count: ${totalTokenCount}\nRemaining context space: ${-thresholdOverrun}`
// );
// console.log({
// compressionThreshold: this.compressionThreshold,
// truncationThreshold,
// thresholdOverrun,
// cumulativeTokenCounts,
// });
if (thresholdOverrun > 0) {
let i = 1;
// prettier-ignore
for (; i < events.length && cumulativeTokenCounts[i - 1] <= truncationThreshold; i++);
// prettier-ignore
for (; i > 0 && cumulativeTokenCounts[i - 1] > this.compressionThreshold; i--);
i = Math.max(i, 3);
const precedingTokens = cumulativeTokenCounts[i - 1];
// console.log({ truncationIndex: i, precedingTokens });
const summaryWordLimit = Math.floor(
(this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6
);
const eventsToSummarize = events.slice(0, i);
// console.log(
// `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize
// .map(countTokens)
// .reduce((sum, next) => sum + next, 0)} tokens)`
// );
const summaryContent = await makeDecision([
...eventsToSummarize,
{
type: "message",
message: messageBuilder.ok(
this.agentId,
`Write a summary in ${summaryWordLimit} words or less of what has happened since (but not including) the introductory message. Include key information that you learned which you don't want to forget. This information will serve as a note to yourself to help you understand what has gone before. Use the second person voice, as if you are someone filling in your replacement who knows nothing. The summarized messages will be omitted from your context window going forward and you will only have this summary to go by, so make it as useful and information-dense as possible. Be as specific as possible, but only include important information. If there are details that seem unimportant, or which you could recover outside of your memory (for instance the particular contents of a file which you could read any time), then omit them from your summary. Once again, your summary must not exceed ${summaryWordLimit} words. In this particular instance, your response should just be raw text, not formatted as an action.`
),
},
]);
const summary = `Several events are omitted here to free up space in your context window, summarized as follows:\n\n${summaryContent}`;
// const summary =
// "Several events are omitted here to free up space in your context window.";
const summaryEvent: Event = {
type: "message",
message: messageBuilder.spontaneous(this.agentId, summary),
};
const summaryTokens = countTokens(summaryEvent);
const tokenSavings =
precedingTokens - summaryTokens - cumulativeTokenCounts[0];
if (tokenSavings > 0) {
// console.log(
// `Summarized events, saving ${tokenSavings} tokens:\n\n${summary}`
// );
const newEvents = [events[0], summaryEvent, ...events.slice(i)];
// const newCumulativeTokenCounts =
// this.getCumulativeTokenCounts(newEvents);
// console.log({ newCumulativeTokenCounts });
return newEvents;
}
}
return events;
}
private getCumulativeTokenCounts(events: Event[]) {
return events.reduce((counts, event) => {
const prevSum = counts.length ? counts[counts.length - 1] : 0;
counts.push(prevSum + countTokens(event));
return counts;
}, [] as number[]);
}
private get key() {
return "memory";
}
private printEvent(event: Event) {
let sourceName: string;
let targetNames: string[];
if (event.type === "message") {
const { message } = event;
sourceName = messageSourceName(message.source);
targetNames = message.targetAgentIds?.map(agentName);
} else {
sourceName = agentName(this.agentId);
targetNames = ["System"];
}
console.log(
`${sourceName} -> ${targetNames.join(", ")}:\n\n${
toOpenAiMessage(event).content
}\n\n=============\n`
);
}
}
function countTokens(event: Event) {
return countTokensInText(toOpenAiMessage(event).content);
}
| src/memory/memory.ts | eumemic-ai-legion-4d145b3 | [
{
"filename": "src/agent.ts",
"retrieved_chunk": " // )\n // );\n // }\n // }, heartbeatInterval);\n }\n private async takeAction(): Promise<void> {\n try {\n let events = await this.memory.retrieve();\n // Do not act again if the last event was a decision\n if (last(events)?.type === \"decision\") return;",
"score": 58.996395370102704
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " const actionText = await makeDecision(events);\n // Reassign events in case summarization occurred\n events = await this.memory.append({\n type: \"decision\",\n actionText,\n });\n const result = parseAction(this.moduleManager.actions, actionText);\n if (result.type === \"error\") {\n this.messageBus.send(messageBuilder.error(this.id, result.message));\n } else {",
"score": 49.33945943601609
},
{
"filename": "src/make-decision.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport { Event } from \"./memory\";\nimport { createChatCompletion } from \"./openai\";\nimport { model } from \"./parameters\";\nimport { messageSourceName } from \"./util\";\nexport default async function makeDecision(events: Event[]): Promise<string> {\n console.log(`Reflecting on ${events.length} events...`);\n const t0 = Date.now();\n const messages = events.map(toOpenAiMessage);\n // console.log(JSON.stringify(messages, null, 2));",
"score": 44.60661597613436
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " if (!fileExists) return undefined;\n const buffer = await readFile(path, \"utf-8\");\n return buffer.toString();\n }\n async set(key: string, value: string) {\n await this.mkdirs();\n await writeFile(this.pathFor(key), value, \"utf-8\");\n }\n async delete(key: string) {\n await this.mkdirs();",
"score": 31.05212042199936
},
{
"filename": "src/store/in-memory-store.ts",
"retrieved_chunk": "import { Store } from \".\";\nexport default class InMemoryStore implements Store<string> {\n private map = new Map<string, string>();\n async get(key: string) {\n return this.map.get(key);\n }\n async set(key: string, value: string) {\n this.map.set(key, value);\n }\n async delete(key: string) {",
"score": 29.49593848205083
}
] | typescript | module): Promise<string[]> => { |
import Notification from "../models/Notification";
import User from "../models/User";
import { randStr } from "./randUtil";
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the recipient.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
*/
export async function addNotification(
text: string,
type: "internal",
recipient: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the sender.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet",
recipient: string,
sender: string,
tweet: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string=} text The message. `%1` is automatically replaced with the username.
* @param {string=} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string=} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet" | "internal",
recipient: string,
sender?: string,
tweet?: string
) {
const id = randStr(64);
if (sender) {
// user-based
const icon = (() => {
if (type === "like") return "heart_icon";
if (type === "reply") return "reply_icon";
if (type === "retweet") return "reweet_icon";
else return "bird_icon";
})();
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
const senderUser = await User.findOne({ id_string: sender });
if (!senderUser) throw new Error(`Sender not found`);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", senderUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: senderUser.name!.length,
ref: {
user: {
id: sender,
},
},
},
],
},
icon: {
id: icon,
},
timestampMs: Date.now(),
template: {
aggregateUserActionsV1: {
targetObjects: [
{
tweet: {
id: tweet,
},
},
],
fromUsers: [
{
user: {
id: sender,
},
},
],
},
},
});
recipientUser.notification_ids.push(id);
| await noti.save(); |
await recipientUser.save();
return;
} else {
// sent from admin
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
recipientUser.notification_ids.push(id);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", recipientUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: recipientUser.name!.length,
ref: {
user: {
id: recipient,
},
},
},
],
},
icon: {
id: "bird_icon",
},
timestampMs: Date.now(),
});
await noti.save();
await recipientUser.save();
return;
}
}
| src/util/notifications.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tif (user.liked_tweet_ids.includes(variables.tweet_id)) {\n\t\tuser.liked_tweet_ids = user.liked_tweet_ids.filter(\n\t\t\t(id) => id !== variables.tweet_id\n\t\t);\n\t\ttweet.favorite_count! -= 1;\n\t\tawait user.save();\n\t\tawait tweet.save();\n\t} else {\n\t\treturn res.status(400).send({ data: { unfavorite_tweet: \"NOT DONE\" } });\n\t}",
"score": 19.53623649471259
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t\tawait user.save();\n\t\tawait tweet.save();\n\t} else {\n\t\treturn res.status(400).send({ data: { favourte_tweet: \"NOT DONE\" } });\n\t}\n\tif (tweet.user_id_str !== user.id_string)\n\t\taddNotification(\n\t\t\t\"%1 liked your tweet!\",\n\t\t\t\"like\",\n\t\t\ttweet.user_id_str!,",
"score": 14.125381769944022
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t) as IUserTweetsVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst user = await User.findOne({ id: variables.userId });\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\tconst userTweets = [];\n\tconst postedTweets = Array.from(user.posted_tweet_ids);\n\tfor (const id of postedTweets) {\n\t\tconst tweet = await Tweet.findOne({ id_str: id });\n\t\tuserTweets.push({",
"score": 14.059707875994244
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tawait user.save();\n\tlog(`${user.name} (@${user.screen_name}) just posted a tweet:`);\n\tlog(`\"${tweet.full_text}\"`);\n\t// addNotification(\n\t// \t\"%1 just posted a tweet!\",\n\t// \t\"reply\",\n\t// \tuser.id_string!,\n\t// \tuser.id_string!,\n\t// \ttweet.id_str!\n\t// );",
"score": 12.118136997066554
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t\tis_quote_status: tweetData.legacy.is_quote_status,\n\t\tlang: tweetData.legacy.lang,\n\t\tquote_count: tweetData.legacy.quote_count,\n\t\treply_count: tweetData.legacy.reply_count,\n\t\tretweet_count: tweetData.legacy.retweet_count,\n\t\tretweeted: tweetData.legacy.retweeted,\n\t\tuser_id_str: tweetData.legacy.user_id_str,\n\t});\n\tawait tweet.save();\n\tuser.posted_tweet_ids.push(tweetId.toString());",
"score": 11.641129409999092
}
] | typescript | await noti.save(); |
import Notification from "../models/Notification";
import User from "../models/User";
import { randStr } from "./randUtil";
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the recipient.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
*/
export async function addNotification(
text: string,
type: "internal",
recipient: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string} text The message. `%1` is automatically replaced with the username of the sender.
* @param {string} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet",
recipient: string,
sender: string,
tweet: string
): Promise<void>;
/**
* Adds a notification to a given user
* @param {string=} text The message. `%1` is automatically replaced with the username.
* @param {string=} recipient The user ID to add the notification to
* @param {"like" | "reply" | "retweet" | "internal"=} type The type of notification. Internal has the Twitter icon, and disallows `sender`.
* @param {string=} sender The user who added the notification
*/
export async function addNotification(
text: string,
type: "like" | "reply" | "retweet" | "internal",
recipient: string,
sender?: string,
tweet?: string
) {
const id = randStr(64);
if (sender) {
// user-based
const icon = (() => {
if (type === "like") return "heart_icon";
if (type === "reply") return "reply_icon";
if (type === "retweet") return "reweet_icon";
else return "bird_icon";
})();
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
const senderUser = await User.findOne({ id_string: sender });
if (!senderUser) throw new Error(`Sender not found`);
| const noti = new Notification({ |
id,
message: {
text: text.replaceAll("%1", senderUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: senderUser.name!.length,
ref: {
user: {
id: sender,
},
},
},
],
},
icon: {
id: icon,
},
timestampMs: Date.now(),
template: {
aggregateUserActionsV1: {
targetObjects: [
{
tweet: {
id: tweet,
},
},
],
fromUsers: [
{
user: {
id: sender,
},
},
],
},
},
});
recipientUser.notification_ids.push(id);
await noti.save();
await recipientUser.save();
return;
} else {
// sent from admin
const recipientUser = await User.findOne({ id_string: recipient });
if (!recipientUser) throw new Error(`Recipient not found`);
recipientUser.notification_ids.push(id);
const noti = new Notification({
id,
message: {
text: text.replaceAll("%1", recipientUser.name!),
rtl: false,
entities: [
{
fromIndex: 0,
toIndex: recipientUser.name!.length,
ref: {
user: {
id: recipient,
},
},
},
],
},
icon: {
id: "bird_icon",
},
timestampMs: Date.now(),
});
await noti.save();
await recipientUser.save();
return;
}
}
| src/util/notifications.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n// \tconst id_string = variables.userId;\n// \tif (!id_string || id_string === \"undefined\")\n// \t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n// \tconst user = await User.findOne({\n// \t\tid_string,\n// \t});\n// \tif (!user) return res.status(200).send({ data: {} });\n// \treturn res.status(200).send({\n// \t\tdata: {",
"score": 72.15213526712284
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tif (unauthorized) return;\n\tconst user = await User.findOne({\n\t\tid_string: (\n\t\t\tverify(req.cookies[\"jwt\"], process.env.JWT_SECRET!) as IJwtDecoded\n\t\t).id.toString(),\n\t});\n\tif (!user) return res.status(400).send({ msg: \"Not authenticated\" });\n\tconst variables = req.body.variables as IFavouriteTweetVariables;\n\tconst tweet = await Tweet.findOne({ id_str: variables.tweet_id });\n\tif (!tweet) return res.status(400).send({ msg: \"Tweet not found\" });",
"score": 71.89428622349216
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByRestIdVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst id_string = variables.userId;\n\tif (!id_string || id_string === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tid_string: {",
"score": 70.01624829091061
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t});\n\tif (!loggedInUser) return res.status(400).send({ msg: \"Not authenticated\" });\n\tconst userTweets = [];\n\tconst postedTweets = await Tweet.find().limit(50);\n\tfor (const tweet of postedTweets) {\n\t\tconst user = await User.findOne({ id_string: tweet.user_id_str });\n\t\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\t\tuserTweets.push({\n\t\t\tis_translatable: false,\n\t\t\tlegacy: Object.assign(tweet, {",
"score": 69.77044569587551
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\tconst user = await User.findOne({\n\t\tid,\n\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tis_super_follow_subscriber: false,\n\t\t\tviewer: {\n\t\t\t\tcreate_community_action_result: {\n\t\t\t\t\t__typename: \"CommunityCreateActionUnavailable\",",
"score": 69.70386035220555
}
] | typescript | const noti = new Notification({ |
import express, { Request, Response } from "express";
import dotenv from "dotenv";
import { searchDirForTsFiles } from "./util/routeUtil";
import * as fs from "fs";
import { IRouteFile } from "./types/route";
import http from "http";
import https from "https";
import cors from "cors";
import mongoose from "mongoose";
import * as mockttp from "mockttp";
import cookieParser from "cookie-parser";
import type { ErrorRequestHandler } from "express";
import { log } from "./util/logging";
import { CallbackResponseMessageResult } from "mockttp/dist/rules/requests/request-handler-definitions";
dotenv.config();
const app = express();
mongoose.connect("mongodb://127.0.0.1:27017/blue");
app.use(express.json());
app.use(cookieParser());
app.use(
cors({
credentials: true,
origin: function (origin, callback) {
if (!origin) return callback(null, true);
return callback(null, true);
},
})
);
async function mountRoute(routePath: string, root: string) {
const router = ((await import(routePath.replace("src/", "./"))) as IRouteFile)
.default;
app.use(root, router);
}
app.use((req, res, next) => {
if (req.path.includes("error_log.json")) next();
// log(
// `${req.path} | ${req.cookies.jwt ? `Logged in?` : `Logged out?`}`
// );
next();
});
const routes11 = searchDirForTsFiles("src/routes/1.1");
const routes11Prefixed = searchDirForTsFiles("src/routes/1.1-prefixed");
const routes2 = searchDirForTsFiles("src/routes/2");
const routesOther = searchDirForTsFiles("src/routes/other");
const twimg = searchDirForTsFiles("src/routes/twimg");
| routes11.forEach(async (routePath) => { |
await mountRoute(routePath, "/1.1");
});
routes11Prefixed.forEach(async (routePath) => {
await mountRoute(routePath, "/i/api/1.1");
});
routes2.forEach(async (routePath) => {
await mountRoute(routePath, "/i/api/2");
});
mountRoute("src/routes/gql/graphQlHandler.ts", "/i/api/graphql");
routesOther.forEach(async (routePath) => {
await mountRoute(routePath, "/");
});
twimg.forEach(async (routePath) => {
await mountRoute(routePath, "/");
});
const errorHandler: ErrorRequestHandler = (err, req, res, next) => {
log(err.stack);
return res.status(500).send({
msg:
"An error occured within the server. Open an issue with the information below on the GitHub, including what you did leading up to this error.\n" +
err.stack,
});
};
app.use(errorHandler);
const options = {
key: fs.readFileSync("certs/testCA.key", "utf8"),
cert: fs.readFileSync("certs/testCA.pem", "utf8"),
};
const httpsServer = https.createServer(options, app);
httpsServer.listen(process.env.PORT, () => {
log(`Blue is listening on port ${process.env.PORT}.`);
});
(async () => {
app.use("/", ((await import("./routes/state/state")) as IRouteFile).default);
const server = mockttp.getLocal({
https: {
keyPath: "certs/testCA.key",
certPath: "certs/testCA.pem",
},
});
server
.forAnyRequest()
.forHostname("twitter.com")
.matching((req) => {
return req.path !== "/" && !req.headers["Sec-Fetch-Dest"];
})
.thenForwardTo("https://localhost", {
ignoreHostHttpsErrors: true,
});
server
.forAnyRequest()
.forHostname("twitter.com")
.matching((req) => {
const condition = req.path.startsWith("/i/api");
return condition;
})
.thenForwardTo("https://localhost", { ignoreHostHttpsErrors: true });
server
.forAnyRequest()
.forHostname("api.twitter.com")
.matching((req) => {
const condition =
req.path.startsWith("/1.1") ||
req.path.startsWith("/img") ||
req.path.startsWith("/graphql");
return condition;
})
.thenForwardTo("https://localhost", { ignoreHostHttpsErrors: true });
server
.forAnyRequest()
.forHostname("abs.twimg.com")
.matching((req) => {
return req.path.startsWith("/images/themes");
})
.thenForwardTo("https://localhost", { ignoreHostHttpsErrors: true });
server
.forAnyRequest()
.forHostname("pbs.twimg.com")
.matching((req) => {
return true;
})
.thenForwardTo("https://localhost", { ignoreHostHttpsErrors: true });
server
.forAnyRequest()
.forHostname("client-api.arkoselabs.com")
.matching((req) => {
const condition =
(req.path.startsWith("/fc") || req.path.startsWith("/rtig")) &&
!req.path.includes("api") &&
!req.path.includes("assets") &&
// !req.path.includes("gt2") &&
!req.path.includes("cdn");
return condition;
})
.thenForwardTo("https://localhost", { ignoreHostHttpsErrors: true });
server.forUnmatchedRequest().thenPassThrough();
await server.start();
log(`Blue proxy is listening on port ${server.port}.`);
})();
| src/index.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/graphQlHandler.ts",
"retrieved_chunk": "import express, { Router } from \"express\";\nimport { log, warn } from \"../../util/logging\";\nimport { searchDirForTsFiles } from \"../../util/routeUtil\";\nconst router = express.Router();\nconst files = searchDirForTsFiles(\"src/routes/gql\");\nconst funcs = [] as ((req: express.Request, res: express.Response) => any)[];\n(async () => {\n\tfor (const pathUnmodified of files) {\n\t\tconst path = pathUnmodified.replace(\"src/routes/gql\", \".\");\n\t\tif (pathUnmodified === \"src/routes/gql/graphQlHandler.ts\") continue;",
"score": 118.35115724328342
},
{
"filename": "src/routes/gql/graphQlHandler.ts",
"retrieved_chunk": "\tlog(`GraphQL query sent to ${query}!`);\n\tfor (const pathUnmodified of files) {\n\t\tif (pathUnmodified === \"src/routes/gql/graphQlHandler.ts\") continue;\n\t\tfor (const fn of funcs) {\n\t\t\tif (fn.name === query) {\n\t\t\t\tawait fn(req, res);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}",
"score": 64.99489757085846
},
{
"filename": "src/util/routeUtil.ts",
"retrieved_chunk": "import * as fs from \"fs\";\nexport function searchDirForTsFiles(dirPath: string): string[] {\n\tconst files = fs.readdirSync(dirPath);\n\tlet tsFiles: string[] = [];\n\tfor (const file of files) {\n\t\tconst filePath = `${dirPath}/${file}`;\n\t\tconst stat = fs.statSync(filePath);\n\t\tif (stat.isDirectory()) {\n\t\t\t// Recursively search subdirectory\n\t\t\tconst subDirTsFiles = searchDirForTsFiles(filePath);",
"score": 52.96702663096554
},
{
"filename": "src/routes/gql/graphQlHandler.ts",
"retrieved_chunk": "\t\tfuncs.push(...(Object.values(await import(path)) as any));\n\t}\n\tlog(\n\t\t`The following GraphQL routes successfully initialized: ${funcs\n\t\t\t.map((fn) => fn.name)\n\t\t\t.join(\", \")}`\n\t);\n})();\nrouter.use(\"*\", async (req, res) => {\n\tconst query = req.originalUrl.split(\"/\").at(-1)!.split(\"?\")[0];",
"score": 51.526616997361025
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tres: express.Response\n) {\n\tconst unauthorized = await requireAuth(req, res);\n\tif (unauthorized) return;\n\tconst userId = req.cookies[\"jwt\"]\n\t\t? ((verify(req.cookies[\"jwt\"], process.env.JWT_SECRET!) as IJwtDecoded)\n\t\t\t\t.id as number)\n\t\t: undefined;\n\tconst loggedInUser = await User.findOne({\n\t\tid_string: userId,",
"score": 38.819080391678156
}
] | typescript | routes11.forEach(async (routePath) => { |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
| const unauthorized = await requireAuth(req, res); |
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t},\n\t});\n}\nexport async function UserByRestId(\n\treq: express.Request,\n\tres: express.Response\n) {\n\tconst features = JSON.parse(\n\t\treq.query.features!.toString()\n\t) as IGenericFeatures;",
"score": 50.19191803254002
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tprofile_image_shape: user.ext_profile_image_shape,\n\t\t\t\t\trest_id: user.id,\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t});\n}\nexport async function ProfileSpotlightsQuery(\n\treq: express.Request,\n\tres: express.Response",
"score": 48.480953980231824
},
{
"filename": "src/routes/gql/blue.ts",
"retrieved_chunk": "import express from \"express\";\nexport function TwitterBlueSignUpV2Query(\n\treq: express.Request,\n\tres: express.Response\n) {\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tblue_marketing_page_config: {\n\t\t\t\tproducts: [\n\t\t\t\t\t{",
"score": 45.29293286426898
},
{
"filename": "src/routes/gql/dm.ts",
"retrieved_chunk": "import express from \"express\";\nexport function DMPinnedInboxQuery(\n\treq: express.Request,\n\tres: express.Response\n) {\n\treturn res.status(200).send({\n\t\tdata: { labeled_conversation_slice: { items: [], slice_info: {} } },\n\t});\n}",
"score": 44.49757268290998
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "import express from \"express\";\nimport User from \"../../models/User\";\nexport async function Viewer(req: express.Request, res: express.Response) {\n\t// if (!req.cookies.twt_id)\n\t// \treturn res.status(400).send({ msg: \"No twid detected\" });\n\tconst id = (req.cookies.twt_id as string | undefined)?.split(\"=\")[1] as\n\t\t| string\n\t\t| undefined;\n\tif (!id || id === \"undefined\")\n\t\treturn res.status(200).send({",
"score": 38.38473435781704
}
] | typescript | const unauthorized = await requireAuth(req, res); |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet.findOne({ id_str: id });
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new | Tweet({ |
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/blue.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t\tcard: {\n\t\t\t\t\ttitle:\n\t\t\t\t\t\t\"Blue subscribers with a verified phone number will get a blue checkmark once approved.\",\n\t\t\t\t\tdescription: \"\",\n\t\t\t\t\timage_url:",
"score": 21.10379230262953
},
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "\t\t\tr: {\n\t\t\t\tok: {},\n\t\t\t},\n\t\t\tttl: {\n\t\t\t\ttype: \"Number\",\n\t\t\t},\n\t\t},\n\t},\n});\nconst Tweet = mongoose.model(\"Tweet\", tweet);",
"score": 18.436566624642378
},
{
"filename": "src/routes/gql/blue.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\t\t\t\"Create Tweets, replies and Quotes up to 10,000 characters long.\",\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\ticon: \"WriteStroke\",\n\t\t\t\t\t\t\t\t\ttitle: \"Edit Tweet\",\n\t\t\t\t\t\t\t\t\tdescription: \"Edit a Tweet up to 5 times within 30 minutes.\",\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\ticon: \"AccountNft\",\n\t\t\t\t\t\t\t\t\ttitle: \"NFT Profile Pictures\",",
"score": 13.770934918726672
},
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "import mongoose from \"mongoose\";\nconst tweet = new mongoose.Schema({\n\tbookmark_count: {\n\t\ttype: \"Number\",\n\t},\n\tbookmarked: {\n\t\ttype: \"Boolean\",\n\t},\n\tconversation_id_str: {\n\t\ttype: \"String\",",
"score": 13.234817331351739
},
{
"filename": "src/routes/gql/blue.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\t\tlearn_more_title: \"\",\n\t\t\t\t\t\t\t\t\tfeatures: [],\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\ttitle:\n\t\t\t\t\t\t\t\t\t\t\"All the existing Blue features, including Edit Tweet, Bookmark Folders and early access to new features\",\n\t\t\t\t\t\t\t\t\tlearn_more_text: \"Learn more\",\n\t\t\t\t\t\t\t\t\tlearn_more_description:\n\t\t\t\t\t\t\t\t\t\t\"Twitter Blue subscribers get early access to new features like these through Twitter Blue Labs.\",\n\t\t\t\t\t\t\t\t\tlearn_more_title: \"Get early access\",",
"score": 13.216802807621292
}
] | typescript | Tweet({ |
import express from "express";
import { verify } from "jsonwebtoken";
import { requireAuth } from "../../middleware/auth";
import Tweet from "../../models/Tweet";
import User from "../../models/User";
import {
ICreateTweetBody,
IGenericFeatures,
IJwtDecoded,
} from "../../types/graphql";
import { IUser } from "../../types/guide";
import { formatDate } from "../../util/formatDate";
import { log } from "../../util/logging";
import { randInt } from "../../util/randUtil";
import { IUserMention } from "./user";
import { addNotification } from "../../util/notifications";
interface IUserTweetsVariables {
userId: string;
count: number;
includePromotedContent: boolean;
withQuickPromoteEligibilityTweetFields: boolean;
withVoice: boolean;
withV2Timeline: boolean;
}
interface IFavouriteTweetVariables {
tweet_id: string;
}
export async function UserTweets(req: express.Request, res: express.Response) {
const loggedInUser = req.cookies["jwt"]
? await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id,
})
: undefined;
const features = JSON.parse(
req.query.features!.toString()
) as IGenericFeatures;
const variables = JSON.parse(
req.query.variables!.toString()
) as IUserTweetsVariables;
if (!features || !variables)
return res.status(400).send({ msg: "Missing parameters" });
const user = await User.findOne({ id: variables.userId });
if (!user) return res.status(400).send({ msg: "User not found" });
const userTweets = [];
const postedTweets = Array.from(user.posted_tweet_ids);
for (const id of postedTweets) {
const tweet = await Tweet | .findOne({ id_str: id }); |
userTweets.push({
is_translatable: false,
legacy: tweet
? Object.assign(tweet, {
favorited: loggedInUser
? loggedInUser.liked_tweet_ids.includes(tweet.id_str || "")
: false,
})
: tweet,
source: tweet?.source,
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
});
}
return res.status(200).send({
data: {
user: {
result: {
__typename: "User",
timeline_v2: {
timeline: {
instructions: [
{
type: "TimelineClearCache",
},
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified:
user.ext_is_blue_verified,
legacy: {
...(user as any)._doc,
},
profile_image_shape:
user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
},
},
});
}
export async function HomeTimeline(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const userId = req.cookies["jwt"]
? ((verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded)
.id as number)
: undefined;
const loggedInUser = await User.findOne({
id_string: userId,
});
if (!loggedInUser) return res.status(400).send({ msg: "Not authenticated" });
const userTweets = [];
const postedTweets = await Tweet.find().limit(50);
for (const tweet of postedTweets) {
const user = await User.findOne({ id_string: tweet.user_id_str });
if (!user) return res.status(400).send({ msg: "User not found" });
userTweets.push({
is_translatable: false,
legacy: Object.assign(tweet, {
favorited: loggedInUser.liked_tweet_ids.includes(tweet.id_str || ""),
}),
unmention_data: {},
unmention_info: {},
views: tweet.ext_views,
user: user,
});
}
return res.status(200).send({
data: {
home: {
home_timeline_urt: {
instructions: [
{
entries: [
...userTweets.map((tweet, index) => {
if (!tweet.legacy) return;
return {
content: {
__typename: "TimelineTimelineItem",
entryType: "TimelineTimelineItem",
itemContent: {
__typename: "TimelineTweet",
itemType: "TimelineTweet",
tweetDisplayType: "Tweet",
tweet_results: {
result: {
__typename: "Tweet",
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
tweet.user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: tweet.user._id,
is_blue_verified:
tweet.user.ext_is_blue_verified,
legacy: {
...(tweet.user as any)._doc,
entities: {
user_mentions: (
tweet.legacy.entities
?.user_mentions as IUserMention[]
).map((mention) => {
return {
a: true,
};
}),
},
},
profile_image_shape:
tweet.user.ext_profile_image_shape,
rest_id: tweet.user.id,
},
},
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: tweet.legacy,
quick_promote_eligibility: {
eligibility: "IneligibleNotProfessional",
},
rest_id: Number(tweet.legacy.id_str),
source: tweet.legacy.source,
unmention_data: {},
views: tweet.views,
},
},
},
},
entryId: `tweet-${tweet.legacy.id_str}`,
sortIndex: index.toString(),
};
}),
],
type: "TimelineAddEntries",
},
],
responseObjects: {
feedbackActions: [
{
key: "589986573",
value: {
feedbackType: "Dismiss",
feedbackUrl:
"/1.1/onboarding/fatigue.json?flow_name=signup-persistent-nux&fatigue_group_name=PersistentNuxFatigueGroup&action_name=dismiss&scribe_name=dismiss&display_location=profile_best&served_time_secs=1682985304&injection_type=tile_carousel",
hasUndoAction: false,
prompt: "See less often",
},
},
],
immediateReactions: [],
},
},
},
},
});
}
export async function FavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (!user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids.push(variables.tweet_id);
tweet.favorite_count! += 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { favourte_tweet: "NOT DONE" } });
}
if (tweet.user_id_str !== user.id_string)
addNotification(
"%1 liked your tweet!",
"like",
tweet.user_id_str!,
user.id_string!,
tweet.id_str!
);
return res.status(200).send({ data: { favorite_tweet: "Done" } });
}
export async function UnfavoriteTweet(
req: express.Request,
res: express.Response
) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const user = await User.findOne({
id_string: (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id.toString(),
});
if (!user) return res.status(400).send({ msg: "Not authenticated" });
const variables = req.body.variables as IFavouriteTweetVariables;
const tweet = await Tweet.findOne({ id_str: variables.tweet_id });
if (!tweet) return res.status(400).send({ msg: "Tweet not found" });
if (user.liked_tweet_ids.includes(variables.tweet_id)) {
user.liked_tweet_ids = user.liked_tweet_ids.filter(
(id) => id !== variables.tweet_id
);
tweet.favorite_count! -= 1;
await user.save();
await tweet.save();
} else {
return res.status(400).send({ data: { unfavorite_tweet: "NOT DONE" } });
}
return res.status(200).send({ data: { unfavorite_tweet: "Done" } });
}
export async function CreateTweet(req: express.Request, res: express.Response) {
const unauthorized = await requireAuth(req, res);
if (unauthorized) return;
const body = req.body as ICreateTweetBody;
const id = (
verify(req.cookies["jwt"], process.env.JWT_SECRET!) as IJwtDecoded
).id as number;
const user = await User.findOne({ id });
if (!user) return res.status(400).send({ msg: "User not found" });
const user_mentions = [] as IUserMention[];
const matches = body.variables.tweet_text.matchAll(/@(\S+)/gm);
for (const match of matches) {
const withTag = match[0];
const withoutTag = match[1];
const user = await User.findOne({ screen_name: withoutTag });
user_mentions.push({
id_str: user?.id_string,
name: user?.name,
screen_name: user?.screen_name,
indices: [match.index, withTag.length + (match.index || 0)],
});
}
const tweetId = randInt(12);
const tweetData = {
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions,
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id: tweetId,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
source:
'<a href="https://mobile.twitter.com" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Enabled",
},
};
const tweet = new Tweet({
bookmark_count: tweetData.legacy.bookmark_count,
bookmarked: tweetData.legacy.bookmarked,
conversation_id_str: tweetData.legacy.conversation_id_str,
created_at: tweetData.legacy.created_at,
display_text_range: tweetData.legacy.display_text_range,
entities: {
hashtags: tweetData.legacy.entities.hashtags,
symbols: tweetData.legacy.entities.symbols,
urls: tweetData.legacy.entities.urls,
user_mentions,
},
favorite_count: tweetData.legacy.favorite_count,
favorited: tweetData.legacy.favorited,
full_text: tweetData.legacy.full_text,
id_str: tweetData.legacy.id_str,
is_quote_status: tweetData.legacy.is_quote_status,
lang: tweetData.legacy.lang,
quote_count: tweetData.legacy.quote_count,
reply_count: tweetData.legacy.reply_count,
retweet_count: tweetData.legacy.retweet_count,
retweeted: tweetData.legacy.retweeted,
user_id_str: tweetData.legacy.user_id_str,
});
await tweet.save();
user.posted_tweet_ids.push(tweetId.toString());
await user.save();
log(`${user.name} (@${user.screen_name}) just posted a tweet:`);
log(`"${tweet.full_text}"`);
// addNotification(
// "%1 just posted a tweet!",
// "reply",
// user.id_string!,
// user.id_string!,
// tweet.id_str!
// );
return res.status(200).send({
// data: {
// create_tweet: {
// tweet_results: {
// result: {
// core: {
// user_results: {
// result: {
// __typename: "User",
// affiliates_highlighted_label:
// user.ext?.highlightedLabel?.r?.ok,
// business_account: {},
// id: user._id,
// is_blue_verified: user.ext_is_blue_verified,
// legacy: {
// created_at: user.created_at,
// default_profile: user.default_profile,
// default_profile_image: user.default_profile_image,
// description: user.description,
// entities: user.entities,
// fast_followers_count: user.fast_followers_count,
// favourites_count: user.favourites_count,
// followers_count: user.followers_count,
// friends_count: user.friends_count,
// has_custom_timelines: user.has_custom_timelines,
// is_translator: user.is_translator,
// listed_count: user.listed_count,
// location: user.location,
// media_count: user.media_count,
// name: user.name,
// normal_followers_count: user.normal_followers_count,
// pinned_tweet_ids_str: user.pinned_tweet_ids_str,
// possibly_sensitive: false,
// profile_image_url_https: user.profile_image_url_https,
// profile_interstitial_type: "",
// screen_name: user.screen_name,
// statuses_count: user.statuses_count,
// translator_type: user.translator_type,
// verified: user.verified,
// withheld_in_countries: user.withheld_in_countries,
// },
// profile_image_shape: user.ext_profile_image_shape,
// rest_id: user.id,
// },
// },
// },
// ...tweetData,
// },
// },
// },
// },
data: {
create_tweet: {
tweet_results: {
result: {
core: {
user_results: {
result: {
__typename: "User",
affiliates_highlighted_label:
user.ext?.highlightedLabel?.r?.ok,
business_account: {},
id: user._id,
is_blue_verified: user.ext_is_blue_verified,
legacy: {
created_at: user.created_at,
default_profile: user.default_profile,
default_profile_image: user.default_profile_image,
description: user.description,
entities: user.entities,
fast_followers_count: user.fast_followers_count,
favourites_count: user.favourites_count,
followers_count: user.followers_count,
friends_count: user.friends_count,
has_custom_timelines: user.has_custom_timelines,
is_translator: user.is_translator,
listed_count: user.listed_count,
location: user.location,
media_count: user.media_count,
name: user.name,
normal_followers_count: user.normal_followers_count,
pinned_tweet_ids_str: user.pinned_tweet_ids_str,
possibly_sensitive: false,
profile_image_url_https: user.profile_image_url_https,
profile_interstitial_type: "",
screen_name: user.screen_name,
statuses_count: user.statuses_count,
translator_type: user.translator_type,
verified: user.verified,
withheld_in_countries: user.withheld_in_countries,
},
profile_image_shape: user.ext_profile_image_shape,
rest_id: user.id,
},
},
},
edit_control: {
edit_tweet_ids: [tweetId.toString()],
editable_until_msecs: "1682984834000",
edits_remaining: "5",
is_edit_eligible: true,
},
edit_perspective: {
favorited: false,
retweeted: false,
},
is_translatable: false,
legacy: {
bookmark_count: 0,
bookmarked: false,
conversation_id_str: tweetId.toString(),
created_at: formatDate(new Date()),
display_text_range: [0, 68],
entities: {
hashtags: [],
symbols: [],
urls: [],
user_mentions: (
tweet.entities!.user_mentions as Array<Array<IUserMention>>
).map((mention) => mention[0]),
},
favorite_count: 0,
favorited: false,
full_text: body.variables.tweet_text,
id_str: tweetId.toString(),
is_quote_status: false,
lang: "en",
quote_count: 0,
reply_count: 0,
retweet_count: 0,
retweeted: false,
user_id_str: user.id_string,
},
rest_id: tweetId.toString(),
source:
'<a href="https://github.com/" rel="nofollow">Blue Web App</a>',
unmention_data: {},
unmention_info: {},
views: {
state: "Disabled",
},
},
},
},
},
});
}
| src/routes/gql/tweet.ts | not-nullptr-blue-3b2284a | [
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IUserByRestIdVariables;\n\tif (!features || !variables)\n\t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n\tconst id_string = variables.userId;\n\tif (!id_string || id_string === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tid_string: {",
"score": 124.14821507364789
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "// \t\treturn res.status(400).send({ msg: \"Missing parameters\" });\n// \tconst id_string = variables.userId;\n// \tif (!id_string || id_string === \"undefined\")\n// \t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n// \tconst user = await User.findOne({\n// \t\tid_string,\n// \t});\n// \tif (!user) return res.status(200).send({ data: {} });\n// \treturn res.status(200).send({\n// \t\tdata: {",
"score": 121.7280309719365
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\tconst user = await User.findOne({\n\t\tid,\n\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tis_super_follow_subscriber: false,\n\t\t\tviewer: {\n\t\t\t\tcreate_community_action_result: {\n\t\t\t\t\t__typename: \"CommunityCreateActionUnavailable\",",
"score": 121.35120670780948
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": ") {\n\tconst variables = JSON.parse(\n\t\treq.query.variables!.toString()\n\t) as IProfileSpotlightsQueryVariables;\n\tif (!variables) return res.status(400).send({ msg: \"Missing parameters\" });\n\tconst screenName = variables.screen_name;\n\tif (!screenName || screenName === \"undefined\")\n\t\treturn res.status(400).send({ msg: \"Error occurred extracting twid\" });\n\tconst user = await User.findOne({\n\t\tscreen_name: screenName,",
"score": 117.95904421718963
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t});\n\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\t// if (user.id !== jwtParams.id)\n\t// \treturn res.status(401).send({ msg: \"Unauthorized\" });\n\treturn res.status(200).send({\n\t\tdata: {\n\t\t\tuser_result_by_screen_name: {\n\t\t\t\tresult: {\n\t\t\t\t\t__typename: \"User\",\n\t\t\t\t\tid: user._id,",
"score": 107.56177059632424
}
] | typescript | .findOne({ id_str: id }); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.