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/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": 0.8636404871940613
},
{
"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": 0.8481820821762085
},
{
"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": 0.801438570022583
},
{
"filename": "src/extension.ts",
"retrieved_chunk": " accountTreeDataProvider.refresh();\n }),\n vscode.commands.registerCommand(\"starkode.editContractAddress\", async (node: ContractTreeItem) => {\n await editContractAddress(node, context);\n }),\n vscode.commands.registerCommand(\"starkode.editInput\", async (node: any) => {\n const selectedContract: string = context.workspaceState.get(\n \"selectedContract\"\n ) as string;\n await editInput(node, abiTreeDataProvider, selectedContract);",
"score": 0.7969236373901367
},
{
"filename": "src/treeView/ABITreeView/AbiTreeDataProvider.ts",
"retrieved_chunk": " [],\n colapse\n )\n );\n }\n }\n } else if (element.abi.type === \"function\") {\n const value: any = inputFunction.find((i: any) => i.name === element.abi.name);\n for (const input of value.inputs) {\n leaves.push(",
"score": 0.7958394289016724
}
] | 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/treeView/ContractTreeView/ContractTreeDataProvider.ts",
"retrieved_chunk": " this._onDidChangeTreeData.fire(undefined);\n }\n}\nexport class Contract extends vscode.TreeItem {\n contextValue: string;\n constructor(\n public readonly label: string,\n public readonly collapsibleState: vscode.TreeItemCollapsibleState,\n public readonly context: string,\n public icon: string",
"score": 0.7651631832122803
},
{
"filename": "src/treeView/ABITreeView/AbiTreeItem.ts",
"retrieved_chunk": "import { TreeItem, TreeItemCollapsibleState, ThemeIcon } from 'vscode';\nexport class Abi extends TreeItem {\n public value: any;\n constructor(\n public readonly label: string,\n public readonly abi: any,\n contextValue: string,\n public parent: Abi | null,\n public children: Abi[],\n public readonly collapsibleState: TreeItemCollapsibleState",
"score": 0.7532373666763306
},
{
"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": 0.7350725531578064
},
{
"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": 0.7326290607452393
},
{
"filename": "src/utils/functions.ts",
"retrieved_chunk": " }\n default:\n break;\n }\n return result;\n};",
"score": 0.7175174355506897
}
] | typescript | children = leaves; |
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/contract.ts",
"retrieved_chunk": " const selectedContract: string = context.workspaceState.get(\n \"selectedContract\"\n ) as string;\n const selectedAccount = context.workspaceState.get(\"account\") as string;\n if (selectedAccount === undefined) {\n logger.log(\"No account selected.\");\n return;\n }\n const accountInfo = getAccountInfo(context, selectedAccount);\n const functionABI = functionabi;",
"score": 0.8441943526268005
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " }\n};\nexport const setContract = async (context: vscode.ExtensionContext, label: string) => {\n if (label === undefined) {\n // logger.log(\"No Contract selected.\");\n return;\n }\n void context.workspaceState.update(\"selectedContract\", `${label}.json`);\n logger.log(`${label} contract selected`);\n createABIFile(`${label}.json`);",
"score": 0.8360227942466736
},
{
"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": 0.8352687358856201
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " quickPick.onDidChangeActive(() => {\n quickPick.placeholder = \"Select Function\";\n });\n quickPick.onDidChangeSelection((selection: any) => {\n if (selection[0] != null) {\n const { label } = selection[0];\n quickPick.dispose();\n const functionItem = contractInfo.filter(\n (i: ABIFragment) => i.name === label\n );",
"score": 0.8350629210472107
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " logger.error(\"Error: Please open your solidity project to vscode\");\n return;\n }\n const path_ = vscode.workspace.workspaceFolders[0].uri.fsPath;\n const provider = getNetworkProvider(context) as Provider;\n const selectedContract: string = context.workspaceState.get(\n \"selectedContract\"\n ) as string;\n const selectedAccount = context.workspaceState.get(\"account\") as string;\n if (selectedAccount === undefined) {",
"score": 0.834938645362854
}
] | typescript | abiTreeDataProvider.refresh(); |
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/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": 0.767769455909729
},
{
"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": 0.7255972623825073
},
{
"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": 0.7146831154823303
},
{
"filename": "src/config/account.ts",
"retrieved_chunk": " });\n } else {\n console.error('Element not found in JSON file.');\n }\n });\n};\nexport const getDeployedAccounts = (context: vscode.ExtensionContext) => {\n const selectedNetwork: any = context.workspaceState.get(\"selectedNetwork\");\n if (selectedNetwork === undefined){\n // logger.log(\"Network not selected\");",
"score": 0.6896892786026001
},
{
"filename": "src/config/contract.ts",
"retrieved_chunk": " const selectedContract: string = context.workspaceState.get(\n \"selectedContract\"\n ) as string;\n const selectedAccount = context.workspaceState.get(\"account\") as string;\n if (selectedAccount === undefined) {\n logger.log(\"No account selected.\");\n return;\n }\n const accountInfo = getAccountInfo(context, selectedAccount);\n const functionABI = functionabi;",
"score": 0.6821706891059875
}
] | typescript | } else if (element.abi.type === "function") { |
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": 0.7781796455383301
},
{
"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": 0.7632863521575928
},
{
"filename": "src/treeView/ABITreeView/AbiTreeDataProvider.ts",
"retrieved_chunk": " [],\n colapse\n )\n );\n }\n }\n } else if (element.abi.type === \"function\") {\n const value: any = inputFunction.find((i: any) => i.name === element.abi.name);\n for (const input of value.inputs) {\n leaves.push(",
"score": 0.7557812929153442
},
{
"filename": "src/treeView/ABITreeView/AbiTreeDataProvider.ts",
"retrieved_chunk": " new Abi(\n input.name,\n input,\n \"abiInput\",\n element,\n [],\n TreeItemCollapsibleState.None\n )\n );\n }",
"score": 0.7553712129592896
},
{
"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": 0.7418185472488403
}
] | typescript | func.state_mutability,
outputs: func.outputs,
}; |
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/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": 0.9006629586219788
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " translations_history: TranslationHistoryBody[];\n}\nexport async function handleUpdatePracticeStatus(\n req: Request<{}, {}, { status: PracticeStatus; wordContent: string }>,\n res: Response,\n next: NextFunction\n) {\n const { user } = req;\n let { status, wordContent } = req.body;\n try {",
"score": 0.8910006284713745
},
{
"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": 0.8878011703491211
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": "export async function handleGetTranslationHistory(\n req: Request<{}, {}, {}, { page: number; limit: number }>,\n res: Response,\n next: NextFunction\n) {\n try {\n const { user } = req;\n let { page, limit } = req.query;\n if (!page) page = 1;\n if (!limit) limit = 18;",
"score": 0.8821142911911011
},
{
"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": 0.8735437393188477
}
] | 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/cambridge.dictionary.ts",
"retrieved_chunk": " return normalizeString(String(div?.textContent));\n });\n return { typeOfWord, sense, examples };\n });\n return { wordContent, typesOfWord: [...new Set(typesOfWord)], senses };\n } catch (error) {\n console.log(\"translateCambridge error \", error);\n return null;\n }\n}",
"score": 0.816012978553772
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " create: {\n word: { connect: { wordContent: word } },\n //@ts-ignore\n user: { connect: { id: user.id } },\n numberOfDaysToForget,\n tag,\n },\n update: {},\n });\n return res.status(201).json(practiceWord);",
"score": 0.8098723292350769
},
{
"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": 0.8077583312988281
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " //multiple create:\n if (translations_history && translations_history.length > 0) {\n const tHistory = await prisma.translationHistory.createMany({\n data: translations_history.map((e) => ({\n word: e.word,\n sense: e.sense,\n currentLanguage: e.currentLanguage,\n targetLanguage: e.targetLanguage,\n //@ts-ignore\n userId: user.id,",
"score": 0.8046809434890747
},
{
"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": 0.7990464568138123
}
] | typescript | wordDb.senses.map((s) => ({ |
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": " 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": 0.7771746516227722
},
{
"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": 0.7674520015716553
},
{
"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": 0.7087813019752502
},
{
"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": 0.6952545642852783
},
{
"filename": "src/libs/oxford.dictionary.ts",
"retrieved_chunk": "import { OXFORD_DICTIONARY_URL } from \"../configs\";\nimport type { Language } from \"../types\";\nimport axios from \"axios\";\nimport { parse } from \"node-html-parser\";\nexport async function getAudioOxford({ word }: { word: string }) {\n let phonetics;\n try {\n const raw_phonetics = await (\n await axios.get(`${OXFORD_DICTIONARY_URL}/definition/english/${word}`)\n ).data;",
"score": 0.6813843250274658
}
] | typescript | `${GLOSBE_API}/iapi3/wordlist?l1=${_format_[0]}&l2=${_format_[1]}&q=${word}&after=20&before=0&env=vi`
)
).data; |
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": 0.9151641130447388
},
{
"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": 0.8319748640060425
},
{
"filename": "src/libs/oxford.dictionary.ts",
"retrieved_chunk": " const document = parse(raw_phonetics);\n phonetics = document\n .querySelectorAll(\".phonetics > div\")\n ?.map((div, idx) => {\n return {\n phrase: div.querySelector(\".phon\")?.textContent,\n author: `OxfordDictionary_${idx === 0 ? \"English\" : \"American\"}`,\n url: div.querySelector(\".sound\")?.getAttribute(\"data-src-mp3\"),\n };\n });",
"score": 0.8205606937408447
},
{
"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": 0.8115754127502441
},
{
"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": 0.7983999252319336
}
] | 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/libs/google.dictionary.ts",
"retrieved_chunk": " \"X-RapidAPI-Host\": `${process.env.RAPID_API_HOST}`,\n },\n data: encodedParams,\n };\n const { data } = await axios.request(options);\n return await data.data.translatedText;\n } catch (error) {\n console.error(\"GOOGLE TRANSLATE ERROR: \", error);\n }\n }",
"score": 0.7685569524765015
},
{
"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": 0.757209300994873
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " } catch (error) {\n console.error(\"handleGetUserInfo ERROR: \", error);\n return res.status(500).json(\"ERROR\");\n }\n}\ninterface TranslationHistoryBody {\n word: string;\n sense: string;\n currentLanguage: string;\n targetLanguage: string;",
"score": 0.7444580793380737
},
{
"filename": "src/libs/cambridge.dictionary.ts",
"retrieved_chunk": " { phrase: us_phonetic, author: \"Cambridge_American\", url: us_audio },\n ];\n } catch (error) {\n console.error(\"get audio cambridge error: \", error);\n }\n return phonetics;\n}\nexport async function translateCambridge({ word }: { word: string }) {\n try {\n const rawData = await (",
"score": 0.7435222268104553
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " create: {\n word: { connect: { wordContent: word } },\n //@ts-ignore\n user: { connect: { id: user.id } },\n numberOfDaysToForget,\n tag,\n },\n update: {},\n });\n return res.status(201).json(practiceWord);",
"score": 0.7433299422264099
}
] | 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/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": 0.8129209280014038
},
{
"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": 0.7928063869476318
},
{
"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": 0.7809515595436096
},
{
"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": 0.7716258764266968
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " !key ||\n typeof key !== \"string\" ||\n key !== `${process.env.CRON_API_KEY}`\n ) {\n return res.status(401).end();\n }\n const start = new Date(Date.now());\n const practices = await prisma.practice.findMany({\n where: {\n status: \"REMEMBERED\",",
"score": 0.7524980306625366
}
] | typescript | prisma.translationHistory.count({ |
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/cambridge.dictionary.ts",
"retrieved_chunk": " return normalizeString(String(div?.textContent));\n });\n return { typeOfWord, sense, examples };\n });\n return { wordContent, typesOfWord: [...new Set(typesOfWord)], senses };\n } catch (error) {\n console.log(\"translateCambridge error \", error);\n return null;\n }\n}",
"score": 0.8214892148971558
},
{
"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": 0.81779944896698
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " create: {\n word: { connect: { wordContent: word } },\n //@ts-ignore\n user: { connect: { id: user.id } },\n numberOfDaysToForget,\n tag,\n },\n update: {},\n });\n return res.status(201).json(practiceWord);",
"score": 0.814298152923584
},
{
"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": 0.8079368472099304
},
{
"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": 0.8062068819999695
}
] | typescript | senses: wordDb.senses.map((s) => ({ |
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/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": 0.7741097211837769
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " !key ||\n typeof key !== \"string\" ||\n key !== `${process.env.CRON_API_KEY}`\n ) {\n return res.status(401).end();\n }\n const start = new Date(Date.now());\n const practices = await prisma.practice.findMany({\n where: {\n status: \"REMEMBERED\",",
"score": 0.7291539907455444
},
{
"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": 0.7271707057952881
},
{
"filename": "src/controllers/wordController.ts",
"retrieved_chunk": " },\n }),\n prisma.typeOfWord.createMany({\n data:\n //@ts-ignore\n resData.typesOfWord && resData.typesOfWord.length > 0\n ? //@ts-ignore\n resData.typesOfWord.map((e) => ({ type: e }))\n : [],\n skipDuplicates: true,",
"score": 0.7162400484085083
},
{
"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": 0.7101448774337769
}
] | 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/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": 0.8957657814025879
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " translations_history: TranslationHistoryBody[];\n}\nexport async function handleUpdatePracticeStatus(\n req: Request<{}, {}, { status: PracticeStatus; wordContent: string }>,\n res: Response,\n next: NextFunction\n) {\n const { user } = req;\n let { status, wordContent } = req.body;\n try {",
"score": 0.8878859281539917
},
{
"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": 0.8850754499435425
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": "export async function handleGetTranslationHistory(\n req: Request<{}, {}, {}, { page: number; limit: number }>,\n res: Response,\n next: NextFunction\n) {\n try {\n const { user } = req;\n let { page, limit } = req.query;\n if (!page) page = 1;\n if (!limit) limit = 18;",
"score": 0.8828147649765015
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": "export async function handleCreateFavorite(\n req: Request<\n {},\n {},\n { word: string; tag?: string; numberOfDaysToForget?: number }\n >,\n res: Response,\n next: NextFunction\n) {\n const { word, numberOfDaysToForget, tag } = req.body;",
"score": 0.8748685717582703
}
] | 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/controllers/userController.ts",
"retrieved_chunk": " res: Response,\n next: NextFunction\n) {\n const { user } = req;\n let { status, page, tag, limit } = req.query;\n if (!page) page = 1;\n if (!limit) limit = 18;\n try {\n const [words, totalRecords] = await prisma.$transaction([\n prisma.practice.findMany({",
"score": 0.8319831490516663
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " next: NextFunction\n) {\n const { word } = req.body;\n const { user } = req;\n try {\n const deletedStatus = await prisma.practice.delete({\n where: {\n userId_wordContent: {\n //@ts-ignore\n userId: user.id,",
"score": 0.8282996416091919
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " })),\n skipDuplicates: true,\n });\n return res.status(201).json(tHistory);\n }\n //single create:\n const tHistory = await prisma.translationHistory.upsert({\n where: {\n userId_word: {\n //@ts-ignore",
"score": 0.8104684352874756
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " const { user } = req;\n if (deleteOption === \"deleteAll\") {\n const deleteStatus = await prisma.translationHistory.deleteMany({\n //@ts-ignore\n where: { userId: user.id },\n });\n return res.status(200).json({ deleteStatus });\n }\n const deleteStatus = await prisma.translationHistory.delete({\n where: {",
"score": 0.7998494505882263
},
{
"filename": "src/controllers/userController.ts",
"retrieved_chunk": " //@ts-ignore\n status: { in: _status_ },\n },\n }),\n ]);\n return res\n .status(200)\n .json({ practices, totalPages: Math.ceil(totalRecords / limit) });\n } catch (error) {\n console.error(`handleGetWordsPreview: ${error}`);",
"score": 0.7951136827468872
}
] | typescript | const [word] = await prisma.$transaction([
prisma.word.create({ |
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": 0.8784275054931641
},
{
"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": 0.8321282863616943
},
{
"filename": "src/libs/oxford.dictionary.ts",
"retrieved_chunk": " const document = parse(raw_phonetics);\n phonetics = document\n .querySelectorAll(\".phonetics > div\")\n ?.map((div, idx) => {\n return {\n phrase: div.querySelector(\".phon\")?.textContent,\n author: `OxfordDictionary_${idx === 0 ? \"English\" : \"American\"}`,\n url: div.querySelector(\".sound\")?.getAttribute(\"data-src-mp3\"),\n };\n });",
"score": 0.8174154758453369
},
{
"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": 0.8117833137512207
},
{
"filename": "src/libs/glosbe.dictionary.ts",
"retrieved_chunk": " \"#tmem_first_examples > div.px-1.text-sm.text-gray-900.break-words > div > div.py-2.flex\"\n )\n .map((div) => {\n return {\n [language_1]: normalizeString(\n String(div.querySelector(\"div:nth-child(1)\")?.textContent)\n ),\n [`keyword_${language_1}`]: div.querySelector(\n \"div:nth-child(1) .keyword\"\n )",
"score": 0.7938830256462097
}
] | 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>({ ...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": 0.774753212928772
},
{
"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": 0.7672285437583923
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": " timestamp,\n duration,\n prompts,\n model\n }\n if (isChatResponse(res)) {\n const { message, supportingText } = res;\n Object.assign(metrics, { data: { message, supportingText } });\n }\n if (isCompletionResponse(res)) {",
"score": 0.7240997552871704
},
{
"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": 0.7176367044448853
},
{
"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": 0.7086638808250427
}
] | 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/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": 0.7907697558403015
},
{
"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": 0.7857293486595154
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "// &&&\n// @@@\n// const \\${prompt1} = { type definition will appear here };\n// @@@\n// &&&\n// ` }\n// ]\nexport const createTypeMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'As a TypescriptTypeGeneratorGPT, generate a Typescript type definition for ${prompt1}.' },\n { role: 'assistant', content: `Internal Process:",
"score": 0.7828725576400757
},
{
"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": 0.7821195125579834
},
{
"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": 0.7816522121429443
}
] | 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": 0.8243893384933472
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " });\n if (!files.length) {\n throw 'No file found.';\n }\n if (files.length > 1) {\n throw 'Multiple files were found. Please specifiy with a local folder path.';\n }\n const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });\n console.log({ gotfiles: files, fileContent})\n return files.length > 0 ? fileContent : null;",
"score": 0.8151443004608154
},
{
"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": 0.7897472977638245
},
{
"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": 0.7828284502029419
},
{
"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": 0.7787915468215942
}
] | 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": 0.8384265303611755
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// export async function modifyStatementsInFile(\n// modifications: (statement: Statements) => Statements | null\n// ): Promise<string> {\n// const files = fs.readdirSync('../files');\n// const modificationFileName = files.find(f => f.startsWith('modifications'));\n// const root = await parseFile();\n// const modifiedRoot = modifyStatements(root.rootNode, modifications);\n// // Serialize the modified AST back to the source code\n// // You can use a library like \"ast-pretty-print\" or write your own serialization function\n// const modifiedCode = serializeAstToCode(modifiedRoot);",
"score": 0.8373968601226807
},
{
"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": 0.8208202123641968
},
{
"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": 0.8175601959228516
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// import fs from 'fs';\nimport type { Node, Statements } from '../lib/types';\n// import { parseFile } from './getStatements';\nexport function modifyStatements(\n node: Node,\n modifications: (statement: Statements) => Statements | null\n): Node | null {\n // Modify, add or delete statements based on modifications function\n const statement = { type: node.type, text: node.text };\n const modifiedStatement = modifications(statement);",
"score": 0.8110631704330444
}
] | typescript | const generatedStatements = res.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/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": 0.8194043636322021
},
{
"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": 0.7842189073562622
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " }\n}\nfunction startContainerIfNotRunning() {\n const containerStatus = execSync(`docker inspect --format='{{.State.Status}}' ${containerName}`).toString().trim();\n if (containerStatus !== 'running') {\n execSync(`docker start ${containerName}`);\n }\n}\nfunction getTempFilePath(fileName: string, content: string): string {\n const tempDir = os.tmpdir();",
"score": 0.757836639881134
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Function to save the configuration\nexport function saveConfig(): void {\n fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));\n}\nexport function setConfig(newConfig: Config): void {\n config = newConfig;\n}\nexport function getConfig(): Config {\n return config;\n}",
"score": 0.7511570453643799
},
{
"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": 0.744126558303833
}
] | typescript | return 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/tree/modifyStatements.ts",
"retrieved_chunk": "// export async function modifyStatementsInFile(\n// modifications: (statement: Statements) => Statements | null\n// ): Promise<string> {\n// const files = fs.readdirSync('../files');\n// const modificationFileName = files.find(f => f.startsWith('modifications'));\n// const root = await parseFile();\n// const modifiedRoot = modifyStatements(root.rootNode, modifications);\n// // Serialize the modified AST back to the source code\n// // You can use a library like \"ast-pretty-print\" or write your own serialization function\n// const modifiedCode = serializeAstToCode(modifiedRoot);",
"score": 0.839668333530426
},
{
"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": 0.8391106128692627
},
{
"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": 0.8233751058578491
},
{
"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": 0.8123654127120972
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// import fs from 'fs';\nimport type { Node, Statements } from '../lib/types';\n// import { parseFile } from './getStatements';\nexport function modifyStatements(\n node: Node,\n modifications: (statement: Statements) => Statements | null\n): Node | null {\n // Modify, add or delete statements based on modifications function\n const statement = { type: node.type, text: node.text };\n const modifiedStatement = modifications(statement);",
"score": 0.8119924664497375
}
] | typescript | = res.message.reduce((m, d) => ({ ...m, ...d }), {}); |
// 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": 0.8205156326293945
},
{
"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": 0.8069312572479248
},
{
"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": 0.7735646367073059
},
{
"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": 0.7731279134750366
},
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " isCreateApiResult,\n isCreateApiBackendResult,\n isGeneralComponentResponse\n];\nexport function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void {\n responseValidators = responseValidators.concat(validators);\n}\nexport function validateTypedResponse<T>(response: string): T {\n if (!response) {\n throw new Error('empty response');",
"score": 0.7701554298400879
}
] | typescript | (config: Config, keys: string[]): [Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>>, string] { |
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": 0.8422151803970337
},
{
"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": 0.8332074880599976
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n throw new Error('invalid prompting procedure');\n}\nexport async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {\n console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))\n if (isChatRequest(request)) {\n const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);\n console.log({ RAW_CHAT: chatResponse.data.choices[0] });\n return chatResponse.data.choices[0]?.message?.content.trim();\n } else if (isCompletionRequest(request)) {",
"score": 0.8304165005683899
},
{
"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": 0.8279639482498169
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": " timestamp,\n duration,\n prompts,\n model\n }\n if (isChatResponse(res)) {\n const { message, supportingText } = res;\n Object.assign(metrics, { data: { message, supportingText } });\n }\n if (isCompletionResponse(res)) {",
"score": 0.8195942640304565
}
] | 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 if (!files.length) {\n throw 'No file found.';\n }\n if (files.length > 1) {\n throw 'Multiple files were found. Please specifiy with a local folder path.';\n }\n const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });\n console.log({ gotfiles: files, fileContent})\n return files.length > 0 ? fileContent : null;",
"score": 0.7837586402893066
},
{
"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": 0.75261390209198
},
{
"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": 0.747101366519928
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " fileModified = true;\n }\n } else {\n const originalStatement = originalStatements.get(stKey);\n if (originalStatement) {\n const originalIndex = fileContent.indexOf(originalStatement);\n if (originalIndex >= 0 && originalStatement !== generatedStatements[stKey]) {\n fileContent = fileContent.substring(0, originalIndex) + generatedStatements[stKey] + fileContent.substring(originalIndex + originalStatement.length);\n fileModified = true;\n }",
"score": 0.7438156604766846
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " type: 'string',\n array: true,\n demandOption: true\n });\n },\n async (argv) => {\n await spells.fileEditor(argv.fileName, ...argv.instructions)\n .then((result) => console.log(result))\n .catch((error) => console.error(error));\n }",
"score": 0.741683304309845
}
] | typescript | const saved = saveTargetFile(fileName, editedFile); |
#!/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/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": 0.7952836751937866
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.7951266765594482
},
{
"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": 0.7819989919662476
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n throw new Error('invalid prompting procedure');\n}\nexport async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {\n console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))\n if (isChatRequest(request)) {\n const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);\n console.log({ RAW_CHAT: chatResponse.data.choices[0] });\n return chatResponse.data.choices[0]?.message?.content.trim();\n } else if (isCompletionRequest(request)) {",
"score": 0.7812103033065796
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " for (const token in promptTokens) {\n item.content = item.content.replaceAll(token, promptTokens[token]);\n }\n }\n }\n const chatRequest = {\n model: config.ai.chatModel,\n messages: messageHistory\n };\n return [chatRequest, originalPromptTemplate]",
"score": 0.7800155878067017
}
] | typescript | .catch((error) => console.error(error)); |
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": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.8163944482803345
},
{
"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": 0.8107785582542419
},
{
"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": 0.8077515363693237
},
{
"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": 0.7988975048065186
},
{
"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": 0.7981114387512207
}
] | 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": 0.8543955087661743
},
{
"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": 0.8241958022117615
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n};\nexport function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {\n const config = getConfig();\n if (!promptType) {\n const moderationRequest: CreateModerationRequest = {\n input: prompts[0]\n }\n return [moderationRequest];\n }",
"score": 0.8180248141288757
},
{
"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": 0.8057286143302917
},
{
"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": 0.8041231632232666
}
] | typescript | !isConfigNestedObject(current[keys[i]])) { |
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": " }\n throw new Error('invalid prompting procedure');\n}\nexport async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {\n console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))\n if (isChatRequest(request)) {\n const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);\n console.log({ RAW_CHAT: chatResponse.data.choices[0] });\n return chatResponse.data.choices[0]?.message?.content.trim();\n } else if (isCompletionRequest(request)) {",
"score": 0.833544135093689
},
{
"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": 0.830864429473877
},
{
"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": 0.8193740248680115
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": " timestamp,\n duration,\n prompts,\n model\n }\n if (isChatResponse(res)) {\n const { message, supportingText } = res;\n Object.assign(metrics, { data: { message, supportingText } });\n }\n if (isCompletionResponse(res)) {",
"score": 0.8107819557189941
},
{
"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": 0.8061884045600891
}
] | typescript | async function resolveAttempt(attempt: string, retriesRemaining: number): Promise<ChatResponse<T>> { |
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/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": 0.8050858974456787
},
{
"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": 0.7793195247650146
},
{
"filename": "src/tree/docker.ts",
"retrieved_chunk": " }\n}\nfunction startContainerIfNotRunning() {\n const containerStatus = execSync(`docker inspect --format='{{.State.Status}}' ${containerName}`).toString().trim();\n if (containerStatus !== 'running') {\n execSync(`docker start ${containerName}`);\n }\n}\nfunction getTempFilePath(fileName: string, content: string): string {\n const tempDir = os.tmpdir();",
"score": 0.7637272477149963
},
{
"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": 0.7462123036384583
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "// Function to save the configuration\nexport function saveConfig(): void {\n fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));\n}\nexport function setConfig(newConfig: Config): void {\n config = newConfig;\n}\nexport function getConfig(): Config {\n return config;\n}",
"score": 0.7365456223487854
}
] | 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": 0.7696499824523926
},
{
"filename": "src/server/git/push_commit.ts",
"retrieved_chunk": " const git = simpleGit(config.git.rootPath);\n console.log('Adding ', path, ' to ', branch);\n await git.add(path);\n const commitMsg = sanitizeName(msg).slice(0, 50);\n console.log('Creating commit:', commitMsg);\n await git.commit(commitMsg);\n console.log('Pushing changes to ', branch);\n await git.push(config.git.remote, branch);\n}",
"score": 0.7544770240783691
},
{
"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": 0.7474651336669922
},
{
"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": 0.7335857152938843
},
{
"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": 0.7318728566169739
}
] | typescript | prRes = await managePullRequest(generatedBranch, prTitle, prBody); |
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": "// 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": 0.7666282057762146
},
{
"filename": "src/server/git/push_commit.ts",
"retrieved_chunk": "import simpleGit from \"simple-git\";\nimport { sanitizeName } from \"../util\";\nimport { getConfig } from \"../config\";\nimport { gitCheck } from \"./check_git_cli\";\nexport async function pushCommit(path: string, branch: string, msg: string) {\n gitCheck();\n const config = getConfig();\n if (!config.git.rootPath) {\n throw 'Missing config.git.rootPath.'\n }",
"score": 0.7153459787368774
},
{
"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": 0.7071413993835449
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": "#!/usr/bin/env node\nimport yargs from 'yargs/yargs';\nimport { config, saveConfig, getConfigValue, checkConfigExists } from './config';\nimport * as spells from './spells';\nimport { IPrompts } from '../lib/prompts';\nconst parser = yargs(process.argv.slice(2))\n // .options({\n // 'config': {\n // alias: 'c',\n // describe: 'Path to the configuration file',",
"score": 0.7043808102607727
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": "import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';\nimport { useAi } from './use_ai_spell';\nimport { IPrompts } from '../../lib/prompts';\nimport { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';\nimport { getConfig } from '../config';\nimport { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';\nfunction getStatementText(child: Node) {\n let parsedStatementText = child.getText();\n const parent = child.getParent();\n if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {",
"score": 0.7012841701507568
}
] | typescript | export function 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": 0.8249257802963257
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " });\n if (!files.length) {\n throw 'No file found.';\n }\n if (files.length > 1) {\n throw 'Multiple files were found. Please specifiy with a local folder path.';\n }\n const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });\n console.log({ gotfiles: files, fileContent})\n return files.length > 0 ? fileContent : null;",
"score": 0.8119173049926758
},
{
"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": 0.7895268201828003
},
{
"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": 0.781636118888855
},
{
"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": 0.7778645753860474
}
] | typescript | 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": " 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": 0.9148952960968018
},
{
"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": 0.8522323369979858
},
{
"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": 0.8296358585357666
},
{
"filename": "src/server/spells/create_type_spell.ts",
"retrieved_chunk": " }\n if (!isValidName(typeName)) {\n throw new Error('this prompt typeName must follow ITypeName format, leading I, titleized');\n }\n const coreTypesPath = sanitizeName(config.ts.typeDir);\n const typeFilePath = getPathOf(`${coreTypesPath}/${toSnakeCase(typeName)}.ts`);\n const comment = `/*\\n* @category ${toTitleCase(typeName)}\\n*/\\n`; \n const generatedType = await useAi<CreateTypeResponse>(IPrompts.CREATE_TYPE, typeName)\n if (!fs.existsSync(coreTypesPath)) {\n fs.mkdirSync(coreTypesPath, { recursive: true });",
"score": 0.7939340472221375
},
{
"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": 0.7823081016540527
}
] | typescript | prepareBranch(editingUser || config.user.name); |
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/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": 0.7581820487976074
},
{
"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": 0.7533559799194336
},
{
"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": 0.7473586797714233
},
{
"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": 0.7464258670806885
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n};\nexport function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {\n const config = getConfig();\n if (!promptType) {\n const moderationRequest: CreateModerationRequest = {\n input: prompts[0]\n }\n return [moderationRequest];\n }",
"score": 0.7433516979217529
}
] | typescript | export function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void { |
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": 0.8100889921188354
},
{
"filename": "src/lib/prompts/create_type_prompt.ts",
"retrieved_chunk": "// &&&\n// @@@\n// const \\${prompt1} = { type definition will appear here };\n// @@@\n// &&&\n// ` }\n// ]\nexport const createTypeMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'As a TypescriptTypeGeneratorGPT, generate a Typescript type definition for ${prompt1}.' },\n { role: 'assistant', content: `Internal Process:",
"score": 0.8048807382583618
},
{
"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": 0.8039829730987549
},
{
"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": 0.8006916642189026
},
{
"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": 0.7960723638534546
}
] | typescript | export function isFileEditorResult(obj: GuardValidations): boolean { |
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": 0.816204309463501
},
{
"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": 0.8122076988220215
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.8097066283226013
},
{
"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": 0.8078979253768921
},
{
"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": 0.807501494884491
}
] | 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>({ ...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": 0.8210767507553101
},
{
"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": 0.8083484172821045
},
{
"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": 0.7837003469467163
},
{
"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": 0.7827003002166748
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.7786262035369873
}
] | 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/create_api_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\nexport const createApiMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'TemplateTransferGPT transfers the qualities of type script types into Api templates.'},\n { role: 'assistant', content: `I perform each step silently to my self, and then I will give you a response like in Sample Response:\n 1. Define Accepted API_RELATED_TYPE Input: type IDigitalWhiteboard = { manufacturer: string; model: string; screenSize: number; resolution: string; touchSensitive: boolean; connectivity: string[]; interface: string;}\n 2. Assign API_TEMPLATE: const digitalWhiteboardApi = {\\n postDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards',\\n method: 'POST',\\n opts: {} as ApiOptions,\\n queryArg: { manufacturer: '' as string; model: '' as string; },\\n resultType: {} as IDigitalWhiteboard }\\n },\\n putDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards',\\n method: 'PUT',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string } as IDigitalWhiteboard,\\n resultType: {} as IDigitalWhiteboard\\n },\\n getDigitalWhiteboards: {\\n kind: EndpointType.QUERY,\\n url: 'digitalwhiteboards',\\n method: 'GET',\\n opts: {} as ApiOptions,\\n queryArg: {} as Void,\\n resultType: [] as IDigitalWhiteboard[]\\n },\\n getDigitalWhiteboardById: {\\n kind: EndpointType.QUERY,\\n url: 'digitalwhiteboards/:id',\\n method: 'GET',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string },\\n resultType: {} as IDigitalWhiteboard\\n },\\n deleteDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards/:id',\\n method: 'DELETE',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string },\\n resultType: { id : '' as string }\\n },\\n disableDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards/:id/disable',\\n method: 'PUT',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string },\\n resultType: { id: '' as string }\\n }\\n} as const;\n 3. Parse Input: API_RELATED_TYPE is parsed for its attributes, context, and connotation.\n 4. Implement: RESPONSE_BODY is implemented as an API_TEMPLATE using details from API_RELATED_TYPE.\n 5. Verify: RESPONSE_BODY is verified as being a Typescript constant variable incorporating as const and type specified properties (id: '' as string), when applicable.",
"score": 0.8134424090385437
},
{
"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": 0.8115489482879639
},
{
"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": 0.8110218644142151
},
{
"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": 0.8092759847640991
},
{
"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": 0.7965197563171387
}
] | 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": 0.8000988364219666
},
{
"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": 0.7681417465209961
},
{
"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": 0.7636493444442749
},
{
"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": 0.7477114200592041
},
{
"filename": "src/server/cli.ts",
"retrieved_chunk": " type: 'string',\n array: true,\n demandOption: true\n });\n },\n async (argv) => {\n await spells.fileEditor(argv.fileName, ...argv.instructions)\n .then((result) => console.log(result))\n .catch((error) => console.error(error));\n }",
"score": 0.7457996606826782
}
] | 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": 0.8619882464408875
},
{
"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": 0.8557617664337158
},
{
"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": 0.850572943687439
},
{
"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": 0.8424787521362305
},
{
"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": 0.8124039173126221
}
] | 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/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": 0.8158203363418579
},
{
"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": 0.8023103475570679
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " let fileContent = sourceFile.getFullText();\n let fileModified = false;\n Object.keys(generatedStatements).forEach(statementKey => {\n const stKey = statementKey as GuidedEditKeys;\n if (['new_statement', 'newstatement', `statement_${originalStatements.size + 1}`].includes(stKey)) {\n fileContent += `\\n${generatedStatements[stKey]} // generated by ${editingUser || config.user.name}`;\n fileModified = true;\n } else if ([/^above_\\d{1,2}$/, /^below_\\d{1,2}$/].some(regex => regex.test(stKey))) {\n const [direction, index] = stKey.split('_');\n const adjacentStatement = originalStatements.get(`statement_${index}`);",
"score": 0.7797548770904541
},
{
"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": 0.7750828266143799
},
{
"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": 0.7729402780532837
}
] | typescript | hasSimilarKey(item, guidedEditKey)
})); |
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/tree/modifyStatements.ts",
"retrieved_chunk": "// export async function modifyStatementsInFile(\n// modifications: (statement: Statements) => Statements | null\n// ): Promise<string> {\n// const files = fs.readdirSync('../files');\n// const modificationFileName = files.find(f => f.startsWith('modifications'));\n// const root = await parseFile();\n// const modifiedRoot = modifyStatements(root.rootNode, modifications);\n// // Serialize the modified AST back to the source code\n// // You can use a library like \"ast-pretty-print\" or write your own serialization function\n// const modifiedCode = serializeAstToCode(modifiedRoot);",
"score": 0.8317744731903076
},
{
"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": 0.8212271928787231
},
{
"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": 0.8183391094207764
},
{
"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": 0.7959949374198914
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// import fs from 'fs';\nimport type { Node, Statements } from '../lib/types';\n// import { parseFile } from './getStatements';\nexport function modifyStatements(\n node: Node,\n modifications: (statement: Statements) => Statements | null\n): Node | null {\n // Modify, add or delete statements based on modifications function\n const statement = { type: node.type, text: node.text };\n const modifiedStatement = modifications(statement);",
"score": 0.7906650304794312
}
] | typescript | const res = 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/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": 0.8029703497886658
},
{
"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": 0.7767676115036011
},
{
"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": 0.7745167016983032
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// export async function modifyStatementsInFile(\n// modifications: (statement: Statements) => Statements | null\n// ): Promise<string> {\n// const files = fs.readdirSync('../files');\n// const modificationFileName = files.find(f => f.startsWith('modifications'));\n// const root = await parseFile();\n// const modifiedRoot = modifyStatements(root.rootNode, modifications);\n// // Serialize the modified AST back to the source code\n// // You can use a library like \"ast-pretty-print\" or write your own serialization function\n// const modifiedCode = serializeAstToCode(modifiedRoot);",
"score": 0.7637165188789368
},
{
"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": 0.7609415054321289
}
] | typescript | parser.parserName; |
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/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": 0.8207483291625977
},
{
"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": 0.8161717057228088
},
{
"filename": "src/lib/prompts/create_api_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\nexport const createApiMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'TemplateTransferGPT transfers the qualities of type script types into Api templates.'},\n { role: 'assistant', content: `I perform each step silently to my self, and then I will give you a response like in Sample Response:\n 1. Define Accepted API_RELATED_TYPE Input: type IDigitalWhiteboard = { manufacturer: string; model: string; screenSize: number; resolution: string; touchSensitive: boolean; connectivity: string[]; interface: string;}\n 2. Assign API_TEMPLATE: const digitalWhiteboardApi = {\\n postDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards',\\n method: 'POST',\\n opts: {} as ApiOptions,\\n queryArg: { manufacturer: '' as string; model: '' as string; },\\n resultType: {} as IDigitalWhiteboard }\\n },\\n putDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards',\\n method: 'PUT',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string } as IDigitalWhiteboard,\\n resultType: {} as IDigitalWhiteboard\\n },\\n getDigitalWhiteboards: {\\n kind: EndpointType.QUERY,\\n url: 'digitalwhiteboards',\\n method: 'GET',\\n opts: {} as ApiOptions,\\n queryArg: {} as Void,\\n resultType: [] as IDigitalWhiteboard[]\\n },\\n getDigitalWhiteboardById: {\\n kind: EndpointType.QUERY,\\n url: 'digitalwhiteboards/:id',\\n method: 'GET',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string },\\n resultType: {} as IDigitalWhiteboard\\n },\\n deleteDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards/:id',\\n method: 'DELETE',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string },\\n resultType: { id : '' as string }\\n },\\n disableDigitalWhiteboard: {\\n kind: EndpointType.MUTATION,\\n url: 'digitalwhiteboards/:id/disable',\\n method: 'PUT',\\n opts: {} as ApiOptions,\\n queryArg: { id: '' as string },\\n resultType: { id: '' as string }\\n }\\n} as const;\n 3. Parse Input: API_RELATED_TYPE is parsed for its attributes, context, and connotation.\n 4. Implement: RESPONSE_BODY is implemented as an API_TEMPLATE using details from API_RELATED_TYPE.\n 5. Verify: RESPONSE_BODY is verified as being a Typescript constant variable incorporating as const and type specified properties (id: '' as string), when applicable.",
"score": 0.8147313594818115
},
{
"filename": "src/lib/prompts/create_api_backend_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\nexport const createApiBackendMessages: ChatCompletionRequestMessage[] = [\n { role: 'system', content: 'I, TemplateTransferGPT, transfer the qualities of Typescript types into file templates.'},\n { role: 'assistant', content: `I perform each step silently to my self, and then I will give you a response like in Sample Response:\n 1. Define Accepted FILE_RELATED_TYPE Input: type IUuidFiles = { id: string; parentUuid: string; fileId: string; } postUuidFile, putUuidFile, getUuidFiles, getUuidFileById, deleteUuidFile, disableUuidFile' }\n 2. Assign FILE_TEMPLATE: const uuidFilesApiHandlers: ApiHandler<typeof uuidFilesApi> = {\\n postUuidFile: async props => {\\n const { parentUuid: parent_uuid, fileId: file_id } = props.event.body;\\n const { id } = await props.tx.one<IUuidFiles>(\\`\\n INSERT INTO dbtable_schema.uuid_files (parent_uuid, file_id, created_on, created_sub)\\n VALUES ($1, $2, $3, $4::uuid)\\n RETURNING id\\n \\`, [parent_uuid, file_id, utcNowString(), props.event.userSub]);\\n \\n return { id };\\n },\\n putUuidFile: async props => {\\n const { id, parentUuid: parent_uuid, fileId: file_id } = props.event.body;\\n const updateProps = buildUpdate({\\n id,\\n parent_uuid,\\n file_id,\\n updated_on: utcNowString(),\\n updated_sub: props.event.userSub\\n });\\n await props.tx.none(\\`\\n UPDATE dbtable_schema.uuid_files\\n SET \\${updateProps.string}\\n WHERE id = $1\\n \\`, updateProps.array);\\n return { id };\\n },\\n getUuidFiles: async props => {\\n const uuidFiles = await props.db.manyOrNone<IUuidFiles>(\\`\\n SELECT * FROM dbview_schema.enabled_uuid_files\\n \\`);\\n \\n return uuidFiles;\\n },\\n getUuidFileById: async props => {\\n const { id } = props.event.pathParameters;\\n const response = await props.db.one<IUuidFiles>(\\`\\n SELECT * FROM dbview_schema.enabled_uuid_files\\n WHERE id = $1\\n \\`, [id]);\\n \\n return response;\\n },\\n deleteUuidFile: async props => {\\n const { id } = props.event.pathParameters;\\n await props.tx.none(\\`\\n DELETE FROM dbtable_schema.uuid_files\\n WHERE id = $1\\n \\`, [id]);\\n \\n return { id };\\n },\\n disableUuidFile: async props => {\\n const { id, parentUuid: parent_uuid, fileId: file_id } = props.event.body;\\n await props.tx.none(\\`\\n UPDATE dbtable_schema.uuid_files\\n SET enabled = false, updated_on = $3, updated_sub = $4\\n WHERE parent_uuid = $1 AND file_id = $2\\n \\`, [parent_uuid, file_id, utcNowString(), props.event.userSub]);\\n return { id };\\n },\\n} as const;\n 3. Parse Input: FILE_RELATED_TYPE is parsed for its attributes, context, and connotation.\n 4. Implement: RESPONSE_BODY is implemented as an API_TEMPLATE using details from FILE_RELATED_TYPE.\n 5. Verify: RESPONSE_BODY is verified as being a Typescript constant variable incorporating as const and defining .",
"score": 0.8063565492630005
},
{
"filename": "src/lib/prompts/guided_edit_prompt.ts",
"retrieved_chunk": "import { ChatCompletionRequestMessage } from \"openai\";\nimport type { GuardValidations } from \"../types\";\nimport { hasSimilarKey } from \"./prompt_utils\";\n// const guidedEditPrompt = [\n// { role: 'system', content: 'As CodeWhittler I transform STATEMENTS_JSON, deriving RESPONSE_ARRAY from TARGET_STATE modifications.' },\n// { role: 'assistant', content: `Whittling Supplies Required:\n// - STATEMENTS_JSON: a JSON object with string keys and string Typescript code statement values\n// - TARGET_STATE: the desired state of the Typescript code statements\n// Carving Process:\n// 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.",
"score": 0.8062114715576172
}
] | typescript | export function isDerivedInstructionResponse(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/tree/modifyStatements.ts",
"retrieved_chunk": "// export async function modifyStatementsInFile(\n// modifications: (statement: Statements) => Statements | null\n// ): Promise<string> {\n// const files = fs.readdirSync('../files');\n// const modificationFileName = files.find(f => f.startsWith('modifications'));\n// const root = await parseFile();\n// const modifiedRoot = modifyStatements(root.rootNode, modifications);\n// // Serialize the modified AST back to the source code\n// // You can use a library like \"ast-pretty-print\" or write your own serialization function\n// const modifiedCode = serializeAstToCode(modifiedRoot);",
"score": 0.8311614990234375
},
{
"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": 0.819421112537384
},
{
"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": 0.8171231746673584
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// import fs from 'fs';\nimport type { Node, Statements } from '../lib/types';\n// import { parseFile } from './getStatements';\nexport function modifyStatements(\n node: Node,\n modifications: (statement: Statements) => Statements | null\n): Node | null {\n // Modify, add or delete statements based on modifications function\n const statement = { type: node.type, text: node.text };\n const modifiedStatement = modifications(statement);",
"score": 0.7913915514945984
},
{
"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": 0.7907567024230957
}
] | typescript | await useAi<GuidedEditResponse>(IPrompts.GUIDED_EDIT, suggestions, JSON.stringify(parsedStatements)); |
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": 0.8046762347221375
},
{
"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": 0.7999200820922852
},
{
"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": 0.7910991907119751
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": " timestamp,\n duration,\n prompts,\n model\n }\n if (isChatResponse(res)) {\n const { message, supportingText } = res;\n Object.assign(metrics, { data: { message, supportingText } });\n }\n if (isCompletionResponse(res)) {",
"score": 0.7893574237823486
},
{
"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": 0.7867625951766968
}
] | 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/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": 0.7732304930686951
},
{
"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": 0.7536778450012207
},
{
"filename": "src/server/git/push_commit.ts",
"retrieved_chunk": "import simpleGit from \"simple-git\";\nimport { sanitizeName } from \"../util\";\nimport { getConfig } from \"../config\";\nimport { gitCheck } from \"./check_git_cli\";\nexport async function pushCommit(path: string, branch: string, msg: string) {\n gitCheck();\n const config = getConfig();\n if (!config.git.rootPath) {\n throw 'Missing config.git.rootPath.'\n }",
"score": 0.7235250473022461
},
{
"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": 0.7223995923995972
},
{
"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": 0.7223023176193237
}
] | 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": 0.824465274810791
},
{
"filename": "src/server/util.ts",
"retrieved_chunk": " });\n if (!files.length) {\n throw 'No file found.';\n }\n if (files.length > 1) {\n throw 'Multiple files were found. Please specifiy with a local folder path.';\n }\n const fileContent = fs.readFileSync(files[0], { encoding: 'utf-8' });\n console.log({ gotfiles: files, fileContent})\n return files.length > 0 ? fileContent : null;",
"score": 0.7989000082015991
},
{
"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": 0.7846349477767944
},
{
"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": 0.7721492648124695
},
{
"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": 0.7710094451904297
}
] | 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": 0.8833426237106323
},
{
"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": 0.8282157182693481
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n};\nexport function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {\n const config = getConfig();\n if (!promptType) {\n const moderationRequest: CreateModerationRequest = {\n input: prompts[0]\n }\n return [moderationRequest];\n }",
"score": 0.8005347847938538
},
{
"filename": "src/server/parser.ts",
"retrieved_chunk": " isCreateApiResult,\n isCreateApiBackendResult,\n isGeneralComponentResponse\n];\nexport function injectResponseValidators(validators: ((obj: GuardValidations) => boolean)[]): void {\n responseValidators = responseValidators.concat(validators);\n}\nexport function validateTypedResponse<T>(response: string): T {\n if (!response) {\n throw new Error('empty response');",
"score": 0.7880499958992004
},
{
"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": 0.7764917612075806
}
] | typescript | current: Record<string, ConfigPropTypes | Record<string, ConfigPropTypes>> = config; |
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": 0.8538272976875305
},
{
"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": 0.8493547439575195
},
{
"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": 0.8362035155296326
},
{
"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": 0.8357019424438477
},
{
"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": 0.8112868666648865
}
] | typescript | = stripWrappedCharacter(attempt); |
#!/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/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": 0.7933714389801025
},
{
"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": 0.7851060628890991
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.7837901711463928
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n throw new Error('invalid prompting procedure');\n}\nexport async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {\n console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))\n if (isChatRequest(request)) {\n const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);\n console.log({ RAW_CHAT: chatResponse.data.choices[0] });\n return chatResponse.data.choices[0]?.message?.content.trim();\n } else if (isCompletionRequest(request)) {",
"score": 0.7830281257629395
},
{
"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": 0.7763144969940186
}
] | 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": 0.8575348258018494
},
{
"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": 0.82643723487854
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n};\nexport function buildOpenAIRequest(prompts: string[], promptType?: IPrompts): [OpenAIRequestShapes, string?] {\n const config = getConfig();\n if (!promptType) {\n const moderationRequest: CreateModerationRequest = {\n input: prompts[0]\n }\n return [moderationRequest];\n }",
"score": 0.8240443468093872
},
{
"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": 0.8180462121963501
},
{
"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": 0.8056632280349731
}
] | 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": 0.7927488088607788
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": " }\n const project = new Project({\n tsConfigFilePath: config.ts.configPath\n });\n const [fileName, ...suggestedEdits] = fileParts.split(' ');\n const suggestions = suggestedEdits.join(' ');\n const generatedBranch = await prepareBranch(editingUser || config.user.name);\n try {\n const sourceFile = project.getSourceFiles().filter(sf => sf.getFilePath().toLowerCase().includes(fileName.toLowerCase()))[0];\n if (sourceFile) {",
"score": 0.7642775774002075
},
{
"filename": "src/server/config.ts",
"retrieved_chunk": "export function checkConfigExists() {\n if (fs.existsSync(configFilePath)) {\n const rawData = fs.readFileSync(configFilePath);\n config = JSON.parse(rawData.toString());\n } else {\n fs.writeFileSync(configFilePath, JSON.stringify(defaultConfig, null, 2));\n config = defaultConfig;\n }\n}\ncheckConfigExists();",
"score": 0.7614612579345703
},
{
"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": 0.7596132159233093
},
{
"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": 0.7592363357543945
}
] | typescript | const parser = langValues.find(l => l.fileExtension.includes(extension)); |
#!/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/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": 0.7967402935028076
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.786535382270813
},
{
"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": 0.786478579044342
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " }\n throw new Error('invalid prompting procedure');\n}\nexport async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {\n console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))\n if (isChatRequest(request)) {\n const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);\n console.log({ RAW_CHAT: chatResponse.data.choices[0] });\n return chatResponse.data.choices[0]?.message?.content.trim();\n } else if (isCompletionRequest(request)) {",
"score": 0.7828373908996582
},
{
"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": 0.777901291847229
}
] | typescript | ((result) => console.log(result))
.catch((error) => console.error(error)); |
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": " 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": 0.8155002593994141
},
{
"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": 0.8151305913925171
},
{
"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": 0.810498833656311
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.8069674968719482
},
{
"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": 0.8020734190940857
}
] | typescript | createChatCompletion(request, openAIRequestOptions); |
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": 0.8321486711502075
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// export async function modifyStatementsInFile(\n// modifications: (statement: Statements) => Statements | null\n// ): Promise<string> {\n// const files = fs.readdirSync('../files');\n// const modificationFileName = files.find(f => f.startsWith('modifications'));\n// const root = await parseFile();\n// const modifiedRoot = modifyStatements(root.rootNode, modifications);\n// // Serialize the modified AST back to the source code\n// // You can use a library like \"ast-pretty-print\" or write your own serialization function\n// const modifiedCode = serializeAstToCode(modifiedRoot);",
"score": 0.8222357630729675
},
{
"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": 0.806712806224823
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": " if (modifiedStatement) {\n node.text = modifiedStatement.text;\n } else {\n return null;\n }\n node.children = node.children\n .map((child) => modifyStatements(child, modifications))\n .filter((child) => child !== null) as Node[];\n return node;\n}",
"score": 0.7992663383483887
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// import fs from 'fs';\nimport type { Node, Statements } from '../lib/types';\n// import { parseFile } from './getStatements';\nexport function modifyStatements(\n node: Node,\n modifications: (statement: Statements) => Statements | null\n): Node | null {\n // Modify, add or delete statements based on modifications function\n const statement = { type: node.type, text: node.text };\n const modifiedStatement = modifications(statement);",
"score": 0.7881081104278564
}
] | typescript | const stKey = statementKey as GuidedEditKeys; |
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>({ ...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": 0.852739155292511
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.8176162242889404
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": " timestamp,\n duration,\n prompts,\n model\n }\n if (isChatResponse(res)) {\n const { message, supportingText } = res;\n Object.assign(metrics, { data: { message, supportingText } });\n }\n if (isCompletionResponse(res)) {",
"score": 0.7998141050338745
},
{
"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": 0.7824001908302307
},
{
"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": 0.7774819135665894
}
] | 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>({ ...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": 0.814964771270752
},
{
"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": 0.8144794702529907
},
{
"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": 0.7965158820152283
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.7878689765930176
},
{
"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": 0.7865085005760193
}
] | typescript | } else if (isCompletionRequest(request)) { |
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": 0.8689117431640625
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " cleaned.push(event);\n }\n cleaned.reverse();\n // console.log({ events, cleaned });\n return cleaned;\n }\n /**\n * Compress the event history when it becomes too large in order to free up the context window.\n */\n private async summarize(events: Event[]): Promise<Event[]> {",
"score": 0.8603971004486084
},
{
"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": 0.8522315621376038
},
{
"filename": "src/task-queue.ts",
"retrieved_chunk": " this.tasks.push(() => task().then(resolve).catch(reject));\n this.runNext();\n });\n }\n runPeriodically(task: Task, milliseconds: number): void {\n let pending = false;\n this.intervals.push(\n setInterval(() => {\n if (pending) return;\n pending = true;",
"score": 0.835884153842926
},
{
"filename": "src/task-queue.test.ts",
"retrieved_chunk": " });\n });\n describe(\"runPeriodically\", () => {\n it(\"should skip re-scheduling task if still pending\", async () => {\n let numTasksRun = 0;\n const periodicTask = async () => {\n await sleep(100);\n numTasksRun++;\n };\n taskQueue.runPeriodically(periodicTask, 10);",
"score": 0.8268542289733887
}
] | typescript | const actionText = await 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": 0.8699260354042053
},
{
"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": 0.8472987413406372
},
{
"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": 0.8062523007392883
},
{
"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": 0.7920088768005371
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " // \"Several events are omitted here to free up space in your context window.\";\n const summaryEvent: Event = {\n type: \"message\",\n message: messageBuilder.spontaneous(this.agentId, summary),\n };\n const summaryTokens = countTokens(summaryEvent);\n const tokenSavings =\n precedingTokens - summaryTokens - cumulativeTokenCounts[0];\n if (tokenSavings > 0) {\n // console.log(",
"score": 0.7878913283348083
}
] | typescript | const result = parseAction(this.moduleManager.actions, actionText); |
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": "// 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": 0.7800931334495544
},
{
"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": 0.7560840845108032
},
{
"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": 0.7287997603416443
},
{
"filename": "src/server/git/push_commit.ts",
"retrieved_chunk": "import simpleGit from \"simple-git\";\nimport { sanitizeName } from \"../util\";\nimport { getConfig } from \"../config\";\nimport { gitCheck } from \"./check_git_cli\";\nexport async function pushCommit(path: string, branch: string, msg: string) {\n gitCheck();\n const config = getConfig();\n if (!config.git.rootPath) {\n throw 'Missing config.git.rootPath.'\n }",
"score": 0.7244042158126831
},
{
"filename": "src/server/spells/guided_edit_spell.ts",
"retrieved_chunk": "import { FunctionDeclaration, SyntaxKind, Node, Project } from 'ts-morph';\nimport { useAi } from './use_ai_spell';\nimport { IPrompts } from '../../lib/prompts';\nimport { prepareBranch, pushCommit, managePullRequest, goHome } from '../git';\nimport { getConfig } from '../config';\nimport { GuidedEditKeys, GuidedEditResponse } from '../../lib/prompts/guided_edit_prompt';\nfunction getStatementText(child: Node) {\n let parsedStatementText = child.getText();\n const parent = child.getParent();\n if (child.getKind() == SyntaxKind.VariableDeclaration && parent instanceof Node) {",
"score": 0.7236146330833435
}
] | typescript | 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": " 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": 0.7814813256263733
},
{
"filename": "src/server/git/push_commit.ts",
"retrieved_chunk": " const git = simpleGit(config.git.rootPath);\n console.log('Adding ', path, ' to ', branch);\n await git.add(path);\n const commitMsg = sanitizeName(msg).slice(0, 50);\n console.log('Creating commit:', commitMsg);\n await git.commit(commitMsg);\n console.log('Pushing changes to ', branch);\n await git.push(config.git.remote, branch);\n}",
"score": 0.7573029398918152
},
{
"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": 0.7529970407485962
},
{
"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": 0.7462509870529175
},
{
"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": 0.7443926930427551
}
] | typescript | await goHome(); |
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>({ ...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": 0.8537176251411438
},
{
"filename": "src/server/spells/use_ai_spell.ts",
"retrieved_chunk": " const [builtRequest, promptTemplate] = buildOpenAIRequest(prompts, promptType);\n const aiResponse: OpenAIResults = {\n timestamp: new Date(),\n successful: true,\n failures: [],\n rawResponses: [],\n promptTemplate,\n promptType: (!promptType ? 'moderation' : promptType) as IPrompts\n }\n try {",
"score": 0.8209971189498901
},
{
"filename": "src/server/stats.ts",
"retrieved_chunk": " timestamp,\n duration,\n prompts,\n model\n }\n if (isChatResponse(res)) {\n const { message, supportingText } = res;\n Object.assign(metrics, { data: { message, supportingText } });\n }\n if (isCompletionResponse(res)) {",
"score": 0.8022651672363281
},
{
"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": 0.7856733798980713
},
{
"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": 0.7825520038604736
}
] | 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/tree/modifyStatements.ts",
"retrieved_chunk": "// export async function modifyStatementsInFile(\n// modifications: (statement: Statements) => Statements | null\n// ): Promise<string> {\n// const files = fs.readdirSync('../files');\n// const modificationFileName = files.find(f => f.startsWith('modifications'));\n// const root = await parseFile();\n// const modifiedRoot = modifyStatements(root.rootNode, modifications);\n// // Serialize the modified AST back to the source code\n// // You can use a library like \"ast-pretty-print\" or write your own serialization function\n// const modifiedCode = serializeAstToCode(modifiedRoot);",
"score": 0.8358972072601318
},
{
"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": 0.8356490135192871
},
{
"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": 0.8198137879371643
},
{
"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": 0.8103533983230591
},
{
"filename": "src/tree/modifyStatements.ts",
"retrieved_chunk": "// import fs from 'fs';\nimport type { Node, Statements } from '../lib/types';\n// import { parseFile } from './getStatements';\nexport function modifyStatements(\n node: Node,\n modifications: (statement: Statements) => Statements | null\n): Node | null {\n // Modify, add or delete statements based on modifications function\n const statement = { type: node.type, text: node.text };\n const modifiedStatement = modifications(statement);",
"score": 0.8090149760246277
}
] | typescript | 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/request.ts",
"retrieved_chunk": " }\n throw new Error('invalid prompting procedure');\n}\nexport async function performRequest(request: OpenAIRequestShapes): Promise<string | boolean | undefined> {\n console.log('OpenAIActionTrigger =::= ', JSON.stringify(request, null, 2))\n if (isChatRequest(request)) {\n const chatResponse = await openai.createChatCompletion(request, openAIRequestOptions);\n console.log({ RAW_CHAT: chatResponse.data.choices[0] });\n return chatResponse.data.choices[0]?.message?.content.trim();\n } else if (isCompletionRequest(request)) {",
"score": 0.8297794461250305
},
{
"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": 0.8188157081604004
},
{
"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": 0.815879225730896
},
{
"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": 0.8134440183639526
},
{
"filename": "src/server/request.ts",
"retrieved_chunk": " for (const token in promptTokens) {\n item.content = item.content.replaceAll(token, promptTokens[token]);\n }\n }\n }\n const chatRequest = {\n model: config.ai.chatModel,\n messages: messageHistory\n };\n return [chatRequest, originalPromptTemplate]",
"score": 0.8075502514839172
}
] | 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": " 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": 0.8181319832801819
},
{
"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": 0.8078445196151733
},
{
"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": 0.7994154691696167
},
{
"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": 0.793174147605896
},
{
"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": 0.7866300344467163
}
] | typescript | (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/module/definitions/web.ts",
"retrieved_chunk": " } catch (e: any) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Error extracting content from ${url}: ${e.message}`\n )\n );\n }\n },\n },",
"score": 0.8502877950668335
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " sendMessage(messageBuilder.ok(agentId, `Created directory ${path}.`));\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n },\n});\nfunction checkPath(\n agentId: string,",
"score": 0.8358703255653381
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " async execute({\n parameters: { path, content },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await writeFile(path, content, \"utf8\");\n sendMessage(messageBuilder.ok(agentId, `Wrote to ${path}.`));\n } catch (err) {",
"score": 0.8278534412384033
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " if (!checkPath(agentId, destinationPath, sendMessage)) return;\n try {\n await rename(sourcePath, destinationPath);\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Moved ${sourcePath} to ${destinationPath}.`\n )\n );\n } catch (err) {",
"score": 0.8269727230072021
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " )\n );\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n readFile: {\n description: \"Read the contents of a particular file\",\n parameters: {",
"score": 0.8226397037506104
}
] | 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/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": 0.7309390306472778
},
{
"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": 0.717002809047699
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " sendMessage(messageBuilder.ok(agentId, `Created directory ${path}.`));\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n },\n});\nfunction checkPath(\n agentId: string,",
"score": 0.703007698059082
},
{
"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": 0.7028477191925049
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " try {\n const data = await readFile(path, \"utf8\");\n sendMessage(\n messageBuilder.ok(agentId, `Contents of ${path}:\\n\\n${data}`)\n );\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },",
"score": 0.7010337114334106
}
] | typescript | `Missing required parameter \`message\`. ${getUsageText(
messaging.actions.sendMessage
)}`
); |
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": " cleaned.push(event);\n }\n cleaned.reverse();\n // console.log({ events, cleaned });\n return cleaned;\n }\n /**\n * Compress the event history when it becomes too large in order to free up the context window.\n */\n private async summarize(events: Event[]): Promise<Event[]> {",
"score": 0.8693994283676147
},
{
"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": 0.8545169234275818
},
{
"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": 0.8435728549957275
},
{
"filename": "src/task-queue.ts",
"retrieved_chunk": " this.tasks.push(() => task().then(resolve).catch(reject));\n this.runNext();\n });\n }\n runPeriodically(task: Task, milliseconds: number): void {\n let pending = false;\n this.intervals.push(\n setInterval(() => {\n if (pending) return;\n pending = true;",
"score": 0.8435611724853516
},
{
"filename": "src/task-queue.test.ts",
"retrieved_chunk": " });\n });\n describe(\"runPeriodically\", () => {\n it(\"should skip re-scheduling task if still pending\", async () => {\n let numTasksRun = 0;\n const periodicTask = async () => {\n await sleep(100);\n numTasksRun++;\n };\n taskQueue.runPeriodically(periodicTask, 10);",
"score": 0.8315340280532837
}
] | typescript | (last(events)?.type === "decision") return; |
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": 0.8181209564208984
},
{
"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": 0.8006724715232849
},
{
"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": 0.7998151183128357
},
{
"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": 0.7982087135314941
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n deleteFile: {\n description: \"Delete a file\",\n parameters: {\n path: {\n description: \"The path of the file to delete\",\n },",
"score": 0.7918102741241455
}
] | 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": 0.9432721138000488
},
{
"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": 0.9249160289764404
},
{
"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": 0.9229626655578613
},
{
"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": 0.9185956716537476
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " destinationPath: {\n description: \"The new path for the file\",\n },\n },\n async execute({\n parameters: { sourcePath, destinationPath },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, sourcePath, sendMessage)) return;",
"score": 0.914746880531311
}
] | typescript | const maxCompletionTokens = contextWindowSize[model] / 4; |
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": 0.8686704635620117
},
{
"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": 0.8546918630599976
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " },\n },\n async execute({\n parameters: { path },\n context: { agentId },\n sendMessage,\n }) {\n if (!checkPath(agentId, path, sendMessage)) return;\n try {\n await mkdir(path);",
"score": 0.8290749788284302
},
{
"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": 0.8287700414657593
},
{
"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": 0.828683614730835
}
] | typescript | sendMessage(messageBuilder.ok(agentId, "Goal added.")); |
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/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": 0.8346381187438965
},
{
"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": 0.8310493230819702
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " messages: [\n {\n role: \"user\",\n 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}`,\n },\n ],\n })\n )\n );\n const summary = summarizedChunks",
"score": 0.8222627639770508
},
{
"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": 0.819717288017273
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " addGoal: {\n description: \"Add a new goal at the end of your goals list.\",\n parameters: {\n goal: {\n description:\n \"A summary of what you want to achieve (keep this relatively short but information dense)\",\n },\n },\n async execute({\n parameters: { goal },",
"score": 0.7901662588119507
}
] | typescript | MULTILINE_DELIMITER}\` to enclose the parameter value in its entirety.
Example:
${CODE_BLOCK_DELIMITER} |
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/parse-action.ts",
"retrieved_chunk": " extraProps.length > 1 ? \"s\" : \"\"\n } ${extraProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n return { type: \"success\", action: { actionDef, thoughts, parameters } };\n } catch (e: any) {\n return {\n type: \"error\",\n message: e.message,\n };",
"score": 0.810951828956604
},
{
"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": 0.804715633392334
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": "...\n${CODE_BLOCK_DELIMITER}\n`.trim(),\n };\n }\n text = `name: ${text}`;\n const jsonText =\n \"{\" +\n text\n .split(MULTILINE_DELIMITER)",
"score": 0.7930594682693481
},
{
"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": 0.7879700064659119
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " `Note \"${title}\" has been written successfully.`\n )\n );\n },\n },\n viewNote: {\n description: \"Display the content of a note.\",\n parameters: {\n title: {\n description: \"The title of the note to view\",",
"score": 0.7837787866592407
}
] | 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/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": 0.7936067581176758
},
{
"filename": "src/message.ts",
"retrieved_chunk": "export const systemSource: SystemMessageSource = { type: \"system\" };\nexport const agentSource = (id: string): AgentMessageSource => ({\n type: \"agent\",\n id,\n});\nexport const CODE_BLOCK_DELIMITER = \"```\";\nexport const messageBuilder = addMessageTypes({\n spontaneous: singleTargetSystemMessage,\n ok: singleTargetSystemMessage,\n error: singleTargetSystemMessage,",
"score": 0.7611883282661438
},
{
"filename": "src/util.ts",
"retrieved_chunk": " clearInterval(interval);\n resolve();\n }\n }, 1000);\n });\n}\nexport function messageSourceName(source: MessageSource) {\n return source.type === \"system\" ? \"System\" : agentName(source.id);\n}\nexport function agentName(agentId: string) {",
"score": 0.7590502500534058
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": "} from \"../../util\";\nimport { defineModule } from \"../define-module\";\nexport default defineModule({\n name: \"web\",\n}).with({\n actions: {\n searchWeb: {\n description: \"Search the web.\",\n parameters: {\n searchString: {",
"score": 0.7545502781867981
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": "import { defineModule } from \"../define-module\";\nimport { messageBuilder } from \"../../message\";\nimport { agentName } from \"../../util\";\nexport default defineModule({\n name: \"messaging\",\n}).with({\n actions: {\n queryAgentRegistry: {\n description: \"Ask who the other agents are that you can talk to\",\n async execute({ context: { agentId, allAgentIds }, sendMessage }) {",
"score": 0.7527419328689575
}
] | typescript | const result = parseAction(moduleManager.actions, text); |
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": " // 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": 0.8445628881454468
},
{
"filename": "src/module/definitions/web.test.ts",
"retrieved_chunk": " \"getSearchResults\",\n async () => {\n const results = await getSearchResults(`\"e/acc\" explanation and sources`);\n console.log(results?.map((item) => item.title).join(\"\\n\"));\n },\n 5 * 60 * 1000\n);",
"score": 0.7957062125205994
},
{
"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": 0.7937383055686951
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " model,\n maxCompletionTokens,\n url\n );\n sendMessage(\n messageBuilder.ok(\n agentId,\n `Here is a summarized markdown version of the page, in a series of summarized chunks:\\n\\n${pageSummary}`\n )\n );",
"score": 0.7926766276359558
},
{
"filename": "src/agent.ts",
"retrieved_chunk": " this.taskQueue.runPeriodically(() => this.takeAction(), actionInterval);\n // Start heartbeat\n // this.taskQueue.runPeriodically(async () => {\n // const messages = await this.memory.retrieve();\n // const lastMessage = last(messages);\n // if (lastMessage?.type === \"decision\") {\n // this.messageBus.send(\n // messageBuilder.spontaneous(\n // this.id,\n // \"This is your regularly scheduled heartbeat message. Is there anything you need to do?\"",
"score": 0.7799091935157776
}
] | typescript | makeDecision([
...eventsToSummarize,
{ |
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": 0.8397576212882996
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " )\n );\n }\n if (allAgentIds.includes(targetAgentId)) {\n sendMessage(\n messageBuilder.agentToAgent(agentId, [targetAgentId], message)\n );\n } else {\n sendMessage(\n messageBuilder.error(",
"score": 0.8367459774017334
},
{
"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": 0.8153424859046936
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " } catch (e: any) {\n sendMessage(\n messageBuilder.error(\n agentId,\n `Error extracting content from ${url}: ${e.message}`\n )\n );\n }\n },\n },",
"score": 0.812861442565918
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " async execute({\n parameters: { targetAgentId, message },\n context: { agentId, allAgentIds },\n sendMessage,\n }) {\n if (agentId === targetAgentId) {\n return sendMessage(\n messageBuilder.error(\n agentId,\n \"You can't send a message to yourself. Use the `writeNote` action if you want to make notes for yourself.\"",
"score": 0.8067795038223267
}
] | typescript | sendMessage(messageBuilder.ok(agentId, getUsageText(actionDef))); |
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/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": 0.7962967157363892
},
{
"filename": "src/message.ts",
"retrieved_chunk": " agentToAgent: (\n sourceAgentId: string,\n targetAgentIds: string[],\n content: string\n ) => ({\n source: agentSource(sourceAgentId),\n targetAgentIds,\n content,\n }),\n});",
"score": 0.7276136875152588
},
{
"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": 0.7183924913406372
},
{
"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": 0.7159063220024109
},
{
"filename": "src/module/definitions/web.test.ts",
"retrieved_chunk": " \"getSearchResults\",\n async () => {\n const results = await getSearchResults(`\"e/acc\" explanation and sources`);\n console.log(results?.map((item) => item.title).join(\"\\n\"));\n },\n 5 * 60 * 1000\n);",
"score": 0.7150195837020874
}
] | typescript | model: Model,
maxSummaryTokens: number,
url: 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/task-queue.ts",
"retrieved_chunk": " this.tasks.push(() => task().then(resolve).catch(reject));\n this.runNext();\n });\n }\n runPeriodically(task: Task, milliseconds: number): void {\n let pending = false;\n this.intervals.push(\n setInterval(() => {\n if (pending) return;\n pending = true;",
"score": 0.7870298027992249
},
{
"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": 0.7668055891990662
},
{
"filename": "src/main.ts",
"retrieved_chunk": "const agentIds = Array.from({ length: numberOfAgents + 1 }, (_, i) => `${i}`);\nconst messageBus: MessageBus = new InMemoryMessageBus();\nmain();\nasync function main() {\n startConsole(agentIds, messageBus);\n webSocketServer(messageBus, 8080);\n for (const id of agentIds.slice(1)) {\n const moduleManager = new ModuleManager(id, agentIds, [\n core,\n goals,",
"score": 0.7658117413520813
},
{
"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": 0.7626099586486816
},
{
"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": 0.7604125738143921
}
] | 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/module/definitions/web.test.ts",
"retrieved_chunk": " \"getSearchResults\",\n async () => {\n const results = await getSearchResults(`\"e/acc\" explanation and sources`);\n console.log(results?.map((item) => item.title).join(\"\\n\"));\n },\n 5 * 60 * 1000\n);",
"score": 0.7715219259262085
},
{
"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": 0.7675372362136841
},
{
"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": 0.7664763927459717
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " (this.compressionThreshold * AVG_WORDS_PER_TOKEN) / 6\n );\n const eventsToSummarize = events.slice(0, i);\n // console.log(\n // `Summarizing ${eventsToSummarize.length} events (${eventsToSummarize\n // .map(countTokens)\n // .reduce((sum, next) => sum + next, 0)} tokens)`\n // );\n const summaryContent = await makeDecision([\n ...eventsToSummarize,",
"score": 0.7663626670837402
},
{
"filename": "src/store/file-store.ts",
"retrieved_chunk": " return String.fromCharCode(parseInt(encodedChar.slice(1), 16));\n}\nfunction encodeFilename(filename: string): string {\n // Replace invalid characters with their encoded versions\n const replaced = filename.replace(/[\\\\/:*?\"<>|]/g, encodeChar);\n // Limit the filename length, as some file systems have restrictions\n const maxLength = 255;\n const trimmed = replaced.slice(0, maxLength);\n return trimmed;\n}",
"score": 0.764161229133606
}
] | 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/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": 0.7964105606079102
},
{
"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": 0.791506290435791
},
{
"filename": "src/parse-action.ts",
"retrieved_chunk": " extraProps.length > 1 ? \"s\" : \"\"\n } ${extraProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n return { type: \"success\", action: { actionDef, thoughts, parameters } };\n } catch (e: any) {\n return {\n type: \"error\",\n message: e.message,\n };",
"score": 0.7904015183448792
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " try {\n const data = await readFile(path, \"utf8\");\n sendMessage(\n messageBuilder.ok(agentId, `Contents of ${path}:\\n\\n${data}`)\n );\n } catch (err) {\n sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },",
"score": 0.7762839794158936
},
{
"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": 0.7699561715126038
}
] | typescript | message: messageBuilder.spontaneous(
this.agentId,
nestedEvents.flat().join("\n\n")
),
}; |
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": " 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": 0.7840776443481445
},
{
"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": 0.7736519575119019
},
{
"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": 0.7668249011039734
},
{
"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": 0.7557553052902222
},
{
"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": 0.7440004348754883
}
] | typescript | } ${missingProps.map((p) => `\`${p}\``)}. ${getUsageText(actionDef)}`,
}; |
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/parse-action.ts",
"retrieved_chunk": " extraProps.length > 1 ? \"s\" : \"\"\n } ${extraProps.map((p) => `\\`${p}\\``)}. ${getUsageText(actionDef)}`,\n };\n }\n return { type: \"success\", action: { actionDef, thoughts, parameters } };\n } catch (e: any) {\n return {\n type: \"error\",\n message: e.message,\n };",
"score": 0.8108389377593994
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " `Note \"${title}\" has been written successfully.`\n )\n );\n },\n },\n viewNote: {\n description: \"Display the content of a note.\",\n parameters: {\n title: {\n description: \"The title of the note to view\",",
"score": 0.7921273708343506
},
{
"filename": "src/module/definitions/web.ts",
"retrieved_chunk": " )\n );\n },\n },\n readPage: {\n description: \"View a markdown summary of a web page.\",\n parameters: {\n url: {\n description: \"The URL of the web page to read\",\n },",
"score": 0.7722190022468567
},
{
"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": 0.7699120044708252
},
{
"filename": "src/module/definitions/filesystem.ts",
"retrieved_chunk": " sendMessage(messageBuilder.error(agentId, JSON.stringify(err)));\n }\n },\n },\n moveFile: {\n description: \"Move a file to a new location\",\n parameters: {\n sourcePath: {\n description: \"The original path of the file\",\n },",
"score": 0.7691714763641357
}
] | 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": " cleaned.push(event);\n }\n cleaned.reverse();\n // console.log({ events, cleaned });\n return cleaned;\n }\n /**\n * Compress the event history when it becomes too large in order to free up the context window.\n */\n private async summarize(events: Event[]): Promise<Event[]> {",
"score": 0.8696572780609131
},
{
"filename": "src/module/definitions/messaging.ts",
"retrieved_chunk": " agentId,\n `You tried to send your message to an invalid targetAgentId (${JSON.stringify(\n targetAgentId\n )}). You can use the 'queryAgentRegistry' action to see a list of available agents and their agent IDs.`\n )\n );\n }\n },\n },\n },",
"score": 0.8512673377990723
},
{
"filename": "src/module/definitions/notes.ts",
"retrieved_chunk": " `Note \"${title}\" has been written successfully.`\n )\n );\n },\n },\n viewNote: {\n description: \"Display the content of a note.\",\n parameters: {\n title: {\n description: \"The title of the note to view\",",
"score": 0.8404890298843384
},
{
"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": 0.8257713317871094
},
{
"filename": "src/module/definitions/goals.ts",
"retrieved_chunk": " addGoal: {\n description: \"Add a new goal at the end of your goals list.\",\n parameters: {\n goal: {\n description:\n \"A summary of what you want to achieve (keep this relatively short but information dense)\",\n },\n },\n async execute({\n parameters: { goal },",
"score": 0.8207929134368896
}
] | 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": " cleaned.push(event);\n }\n cleaned.reverse();\n // console.log({ events, cleaned });\n return cleaned;\n }\n /**\n * Compress the event history when it becomes too large in order to free up the context window.\n */\n private async summarize(events: Event[]): Promise<Event[]> {",
"score": 0.8695638179779053
},
{
"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": 0.857267439365387
},
{
"filename": "src/task-queue.ts",
"retrieved_chunk": " this.tasks.push(() => task().then(resolve).catch(reject));\n this.runNext();\n });\n }\n runPeriodically(task: Task, milliseconds: number): void {\n let pending = false;\n this.intervals.push(\n setInterval(() => {\n if (pending) return;\n pending = true;",
"score": 0.844390332698822
},
{
"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": 0.8400779366493225
},
{
"filename": "src/task-queue.test.ts",
"retrieved_chunk": " });\n });\n describe(\"runPeriodically\", () => {\n it(\"should skip re-scheduling task if still pending\", async () => {\n let numTasksRun = 0;\n const periodicTask = async () => {\n await sleep(100);\n numTasksRun++;\n };\n taskQueue.runPeriodically(periodicTask, 10);",
"score": 0.8320716619491577
}
] | 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": 0.8697790503501892
},
{
"filename": "src/memory/memory.ts",
"retrieved_chunk": " cleaned.push(event);\n }\n cleaned.reverse();\n // console.log({ events, cleaned });\n return cleaned;\n }\n /**\n * Compress the event history when it becomes too large in order to free up the context window.\n */\n private async summarize(events: Event[]): Promise<Event[]> {",
"score": 0.8539681434631348
},
{
"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": 0.8484317064285278
},
{
"filename": "src/task-queue.ts",
"retrieved_chunk": " this.tasks.push(() => task().then(resolve).catch(reject));\n this.runNext();\n });\n }\n runPeriodically(task: Task, milliseconds: number): void {\n let pending = false;\n this.intervals.push(\n setInterval(() => {\n if (pending) return;\n pending = true;",
"score": 0.8339410424232483
},
{
"filename": "src/task-queue.test.ts",
"retrieved_chunk": " });\n });\n describe(\"runPeriodically\", () => {\n it(\"should skip re-scheduling task if still pending\", async () => {\n let numTasksRun = 0;\n const periodicTask = async () => {\n await sleep(100);\n numTasksRun++;\n };\n taskQueue.runPeriodically(periodicTask, 10);",
"score": 0.8258187770843506
}
] | typescript | makeDecision(events); |
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": 0.8020941019058228
},
{
"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": 0.698699951171875
},
{
"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": 0.6567786335945129
},
{
"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": 0.647225558757782
},
{
"filename": "src/middleware/auth.ts",
"retrieved_chunk": "import { Request, Response, NextFunction } from \"express\";\nimport { verify } from \"jsonwebtoken\";\nimport User from \"../models/User\";\nimport { IJwtDecoded } from \"../types/graphql\";\nexport async function requireAuth(req: Request, res: Response): Promise<any> {\n\tif (!req.cookies[\"jwt\"])\n\t\treturn res\n\t\t\t.status(401)\n\t\t\t.send({ msg: \"No auth token (are you missing your jwt cookie?)\" });\n\ttry {",
"score": 0.6413359642028809
}
] | 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": "\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": 0.8481593132019043
},
{
"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": 0.825198769569397
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\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: {\n\t\t\t$regex: new RegExp(screenName, \"i\"),\n\t\t},\n\t});\n\tif (!user) return res.status(200).send({ data: {} });\n\treturn res.status(200).send({",
"score": 0.8104841709136963
},
{
"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": 0.7924880981445312
},
{
"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": 0.7785504460334778
}
] | typescript | .findOne({ id_str: id }); |
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": 0.8637507557868958
},
{
"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": 0.8003337979316711
},
{
"filename": "src/middleware/auth.ts",
"retrieved_chunk": "import { Request, Response, NextFunction } from \"express\";\nimport { verify } from \"jsonwebtoken\";\nimport User from \"../models/User\";\nimport { IJwtDecoded } from \"../types/graphql\";\nexport async function requireAuth(req: Request, res: Response): Promise<any> {\n\tif (!req.cookies[\"jwt\"])\n\t\treturn res\n\t\t\t.status(401)\n\t\t\t.send({ msg: \"No auth token (are you missing your jwt cookie?)\" });\n\ttry {",
"score": 0.7983594536781311
},
{
"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": 0.7908143997192383
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\t\tv1: [],\n\t\t\t\t\t},\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 AuthenticatedUserTFLists(\n\treq: express.Request,",
"score": 0.7862926721572876
}
] | typescript | const unauthorized = await requireAuth(req, res); |
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": "\t\t// \t\t\t\t\t\t\t},\n\t\t// \t\t\t\t\t\t\tprofile_image_shape: user.ext_profile_image_shape,\n\t\t// \t\t\t\t\t\t\trest_id: user.id,\n\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\t...tweetData,\n\t\t// \t\t\t},\n\t\t// \t\t},\n\t\t// \t},",
"score": 0.7916155457496643
},
{
"filename": "src/routes/gql/viewer.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\tyear: 1999,\n\t\t\t\t\t\t\t\tyear_visibility: \"Self\",\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t\tprofile_image_shape: \"Circle\",\n\t\t\t\t\t\trest_id: user.id,\n\t\t\t\t\t\tsuper_follows_application_status: \"NotStarted\",\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},",
"score": 0.7893288731575012
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t\tentryId: `tweet-${tweet.legacy.id_str}`,\n\t\t\t\t\t\t\t\t\t\tsortIndex: index.toString(),\n\t\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],\n\t\t\t\t\t\t\ttype: \"TimelineAddEntries\",",
"score": 0.7841153144836426
},
{
"filename": "src/models/Tweet.ts",
"retrieved_chunk": "\t\t\t\t\t\t\ttype: \"Boolean\",\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\tttl: {\n\t\t\t\ttype: \"Number\",\n\t\t\t},\n\t\t},\n\t\tunmentionInfo: {",
"score": 0.781228244304657
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\t\tv1: [],\n\t\t\t\t\t},\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 AuthenticatedUserTFLists(\n\treq: express.Request,",
"score": 0.7664427161216736
}
] | typescript | await noti.save(); |
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/state/state.ts",
"retrieved_chunk": "\t\t\t\tresponsive_web_nft_avatar: { value: true },\n\t\t\t\tresponsive_web_nft_avatar_help_link: {\n\t\t\t\t\tvalue:\n\t\t\t\t\t\t\"https://help.twitter.com/en/using-twitter/twitter-blue-labs#nft\",\n\t\t\t\t},\n\t\t\t\tresponsive_web_notifications_empty_state_redesign_variant: {\n\t\t\t\t\tvalue: \"control\",\n\t\t\t\t},\n\t\t\t\tresponsive_web_ntab_verified_mentions_vit_internal_dogfood: {\n\t\t\t\t\tvalue: true,",
"score": 0.7629572153091431
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\tresponsive_web_twitter_article_tweet_own_notes_enabled: {\n\t\t\t\t\tvalue: false,\n\t\t\t\t},\n\t\t\t\tresponsive_web_twitter_article_view_enabled: {\n\t\t\t\t\tvalue: true,\n\t\t\t\t},\n\t\t\t\tresponsive_web_twitter_blue_signup_nux_enabled: {\n\t\t\t\t\tvalue: true,\n\t\t\t\t},\n\t\t\t\tresponsive_web_twitter_blue_subscriptions_disabled: {",
"score": 0.7607779502868652
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\"view_tweet_activity\",\n\t\t\t\t\t\t\t\"vote_on_poll\",\n\t\t\t\t\t\t\t\"highlight\",\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\ttweet_limited_actions_config_community_tweet_member: {\n\t\t\t\t\t\tvalue: [\"embed\", \"pin_to_profile\", \"retweet\", \"highlight\"],\n\t\t\t\t\t},\n\t\t\t\t\ttweet_limited_actions_config_community_tweet_member_removed: {\n\t\t\t\t\t\tvalue: [",
"score": 0.7549553513526917
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\ttweet_with_visibility_results_partial_gql_limited_actions_enabled: {\n\t\t\t\t\tvalue: false,\n\t\t\t\t},\n\t\t\t\ttweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled:\n\t\t\t\t\t{ value: false },\n\t\t\t\ttweetypie_unmention_optimization_enabled: {\n\t\t\t\t\tvalue: true,\n\t\t\t\t},\n\t\t\t\ttwitter_chat_communities_chat_enabled: { value: false },\n\t\t\t\ttwitter_delegate_enabled: { value: false },",
"score": 0.7546069025993347
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\"send_via_dm\",\n\t\t\t\t\t\t\t\"share_tweet_via\",\n\t\t\t\t\t\t\t\"view_hidden_replies\",\n\t\t\t\t\t\t\t\"view_tweet_activity\",\n\t\t\t\t\t\t\t\"vote_on_poll\",\n\t\t\t\t\t\t\t\"highlight\",\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\ttweet_limited_actions_config_community_tweet_community_suspended: {\n\t\t\t\t\t\tvalue: [",
"score": 0.7537567615509033
}
] | typescript | Tweet({ |
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": "\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": 0.7952439785003662
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\tconst user_mentions = [] as IUserMention[];\n\tconst matches = body.variables.tweet_text.matchAll(/@(\\S+)/gm);\n\tfor (const match of matches) {\n\t\tconst withTag = match[0];\n\t\tconst withoutTag = match[1];\n\t\tconst user = await User.findOne({ screen_name: withoutTag });\n\t\tuser_mentions.push({\n\t\t\tid_str: user?.id_string,\n\t\t\tname: user?.name,",
"score": 0.7860839366912842
},
{
"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": 0.7818964719772339
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\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: {\n\t\t\t$regex: new RegExp(screenName, \"i\"),\n\t\t},\n\t});\n\tif (!user) return res.status(200).send({ data: {} });\n\treturn res.status(200).send({",
"score": 0.769939124584198
},
{
"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": 0.7688473463058472
}
] | typescript | const noti = new Notification({ |
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/models/Notification.ts",
"retrieved_chunk": "import mongoose from \"mongoose\";\nconst notification = new mongoose.Schema({\n\tid: String,\n\ttimestampMs: String,\n\ticon: {\n\t\tid: String,\n\t},\n\tmessage: {\n\t\ttext: String,\n\t\t// entities: [",
"score": 0.7194156050682068
},
{
"filename": "src/models/Message.ts",
"retrieved_chunk": "import mongoose from \"mongoose\";\nconst message = new mongoose.Schema({\n\tid: String,\n\ttime: String,\n\taffects_sort: Boolean,\n\trequest_id: String,\n\tconversation_id: String,\n\tmessage_data: {\n\t\tid: String,\n\t\ttime: String,",
"score": 0.7086087465286255
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t\t\tscreen_name: user?.screen_name,\n\t\t\tindices: [match.index, withTag.length + (match.index || 0)],\n\t\t});\n\t}\n\tconst tweetId = randInt(12);\n\tconst tweetData = {\n\t\tedit_perspective: {\n\t\t\tfavorited: false,\n\t\t\tretweeted: false,\n\t\t},",
"score": 0.7061588168144226
},
{
"filename": "src/types/guide.ts",
"retrieved_chunk": "}\nexport interface Broadcasts {}\nexport interface TweetValue {\n\tcreated_at: string;\n\tid: number;\n\tid_str: string;\n\tfull_text: string;\n\ttruncated: boolean;\n\tdisplay_text_range: number[];\n\tentities: TweetEntities;",
"score": 0.6953033208847046
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\t\t\tuser.id_string!,\n\t\t\ttweet.id_str!\n\t\t);\n\treturn res.status(200).send({ data: { favorite_tweet: \"Done\" } });\n}\nexport async function UnfavoriteTweet(\n\treq: express.Request,\n\tres: express.Response\n) {\n\tconst unauthorized = await requireAuth(req, res);",
"score": 0.6782653331756592
}
] | typescript | id = randStr(64); |
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\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str,\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https,\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name,\n\t\t\t\t\t\tstatuses_count: user.statuses_count,\n\t\t\t\t\t\ttranslator_type: user.translator_type,\n\t\t\t\t\t\tverified: user.verified,\n\t\t\t\t\t\twithheld_in_countries: user.withheld_in_countries,\n\t\t\t\t\t},",
"score": 0.7972042560577393
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\t\tlisted_count: user.listed_count,\n\t\t\t\t\t\tlocation: user.location,\n\t\t\t\t\t\tmedia_count: user.media_count,\n\t\t\t\t\t\tname: user.name,\n\t\t\t\t\t\tnormal_followers_count: user.normal_followers_count,\n\t\t\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str,\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https,\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name,",
"score": 0.7965779304504395
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\tnormal_followers_count: user.normal_followers_count || 0,\n\t\t\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str || [],\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https || \"\",\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name || \"\",\n\t\t\t\t\t\tstatuses_count: user.statuses_count || 0,\n\t\t\t\t\t\ttranslator_type: user.translator_type || \"\",\n\t\t\t\t\t\tverified: user.verified || false,\n\t\t\t\t\t\twant_retweets: user.want_retweets || false,",
"score": 0.7947512865066528
},
{
"filename": "src/routes/1.1-prefixed/dms/dms.ts",
"retrieved_chunk": "\t\t\t\t\tprotected: false,\n\t\t\t\t\tblocking: false,\n\t\t\t\t\tcan_media_tag: true,\n\t\t\t\t\tcreated_at: \"Mon Aug 12 03:48:45 +0000 2019\",\n\t\t\t\t\tfriends_count: 329,\n\t\t\t\t\tfollowers_count: 31,\n\t\t\t\t\text_has_nft_avatar: false,\n\t\t\t\t},\n\t\t\t},\n\t\t\tconversations: {",
"score": 0.7865052223205566
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tbusiness_account: {},\n\t\t\t\t\tid: user._id,\n\t\t\t\t\tis_blue_verified: user.ext_is_blue_verified,\n\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tcreated_at: user.created_at,\n\t\t\t\t\t\tdefault_profile: user.default_profile,\n\t\t\t\t\t\tdefault_profile_image: user.default_profile_image,\n\t\t\t\t\t\tdescription: user.description,\n\t\t\t\t\t\tentities: user.entities,\n\t\t\t\t\t\tfast_followers_count: user.fast_followers_count,",
"score": 0.7863665223121643
}
] | typescript | created_at: formatDate(new Date()),
display_text_range: [0, body.variables.tweet_text.length],
entities: { |
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": 0.8205335736274719
},
{
"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": 0.8079885244369507
},
{
"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": 0.7981928586959839
},
{
"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": 0.7963687181472778
},
{
"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": 0.7862170338630676
}
] | typescript | .send(messageBuilder.error(this.id, result.message)); |
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": "\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": 0.7379209995269775
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\tif (!user) return res.status(400).send({ msg: \"User not found\" });\n\tconst user_mentions = [] as IUserMention[];\n\tconst matches = body.variables.tweet_text.matchAll(/@(\\S+)/gm);\n\tfor (const match of matches) {\n\t\tconst withTag = match[0];\n\t\tconst withoutTag = match[1];\n\t\tconst user = await User.findOne({ screen_name: withoutTag });\n\t\tuser_mentions.push({\n\t\t\tid_str: user?.id_string,\n\t\t\tname: user?.name,",
"score": 0.7354874610900879
},
{
"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": 0.7305698394775391
},
{
"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": 0.7115942239761353
},
{
"filename": "src/routes/gql/tweet.ts",
"retrieved_chunk": "\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\" });\n\tif (!user.liked_tweet_ids.includes(variables.tweet_id)) {\n\t\tuser.liked_tweet_ids.push(variables.tweet_id);\n\t\ttweet.favorite_count! += 1;",
"score": 0.7082882523536682
}
] | typescript | const recipientUser = await User.findOne({ id_string: recipient }); |
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\t\t\t\tlisted_count: user.listed_count,\n\t\t\t\t\t\tlocation: user.location,\n\t\t\t\t\t\tmedia_count: user.media_count,\n\t\t\t\t\t\tname: user.name,\n\t\t\t\t\t\tnormal_followers_count: user.normal_followers_count,\n\t\t\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str,\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https,\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name,",
"score": 0.7770398855209351
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tbusiness_account: {},\n\t\t\t\t\tid: user._id,\n\t\t\t\t\tis_blue_verified: user.ext_is_blue_verified,\n\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tcreated_at: user.created_at,\n\t\t\t\t\t\tdefault_profile: user.default_profile,\n\t\t\t\t\t\tdefault_profile_image: user.default_profile_image,\n\t\t\t\t\t\tdescription: user.description,\n\t\t\t\t\t\tentities: user.entities,\n\t\t\t\t\t\tfast_followers_count: user.fast_followers_count,",
"score": 0.746498703956604
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": " `);\n\t}\n\tif (!req.cookies.jwt) return res.redirect(\"https://twitter.com\");\n\tconst user = await User.findOne({\n\t\tid_string: (decode(req.cookies.jwt) as { id: string }).id.toString(),\n\t});\n\tif (!user) return res.redirect(\"https://twitter.com\");\n\tconst __INITIAL_STATE__ = {\n\t\toptimist: [],\n\t\tentities: {",
"score": 0.743086576461792
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\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: {\n\t\t\t$regex: new RegExp(screenName, \"i\"),\n\t\t},\n\t});\n\tif (!user) return res.status(200).send({ data: {} });\n\treturn res.status(200).send({",
"score": 0.7377673387527466
},
{
"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": 0.730944037437439
}
] | typescript | const tweetId = randInt(12); |
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\t\t\t\tlisted_count: user.listed_count,\n\t\t\t\t\t\tlocation: user.location,\n\t\t\t\t\t\tmedia_count: user.media_count,\n\t\t\t\t\t\tname: user.name,\n\t\t\t\t\t\tnormal_followers_count: user.normal_followers_count,\n\t\t\t\t\t\tpinned_tweet_ids_str: user.pinned_tweet_ids_str,\n\t\t\t\t\t\tpossibly_sensitive: false,\n\t\t\t\t\t\tprofile_image_url_https: user.profile_image_url_https,\n\t\t\t\t\t\tprofile_interstitial_type: \"\",\n\t\t\t\t\t\tscreen_name: user.screen_name,",
"score": 0.7944753766059875
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\"view_tweet_activity\",\n\t\t\t\t\t\t\t\"vote_on_poll\",\n\t\t\t\t\t\t\t\"highlight\",\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\ttweet_limited_actions_config_community_tweet_member: {\n\t\t\t\t\t\tvalue: [\"embed\", \"pin_to_profile\", \"retweet\", \"highlight\"],\n\t\t\t\t\t},\n\t\t\t\t\ttweet_limited_actions_config_community_tweet_member_removed: {\n\t\t\t\t\t\tvalue: [",
"score": 0.7656570076942444
},
{
"filename": "src/routes/gql/user.ts",
"retrieved_chunk": "\t\t\t\t\tbusiness_account: {},\n\t\t\t\t\tid: user._id,\n\t\t\t\t\tis_blue_verified: user.ext_is_blue_verified,\n\t\t\t\t\tlegacy: {\n\t\t\t\t\t\tcreated_at: user.created_at,\n\t\t\t\t\t\tdefault_profile: user.default_profile,\n\t\t\t\t\t\tdefault_profile_image: user.default_profile_image,\n\t\t\t\t\t\tdescription: user.description,\n\t\t\t\t\t\tentities: user.entities,\n\t\t\t\t\t\tfast_followers_count: user.fast_followers_count,",
"score": 0.7471504211425781
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\t\t\"send_via_dm\",\n\t\t\t\t\t\t\t\"share_tweet_via\",\n\t\t\t\t\t\t\t\"view_hidden_replies\",\n\t\t\t\t\t\t\t\"view_tweet_activity\",\n\t\t\t\t\t\t\t\"vote_on_poll\",\n\t\t\t\t\t\t\t\"highlight\",\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\ttweet_limited_actions_config_community_tweet_community_suspended: {\n\t\t\t\t\t\tvalue: [",
"score": 0.7458946704864502
},
{
"filename": "src/routes/state/state.ts",
"retrieved_chunk": "\t\t\t\t\t\t\"vote_on_poll\",\n\t\t\t\t\t\t\"highlight\",\n\t\t\t\t\t],\n\t\t\t\t},\n\t\t\t\ttweet_limited_actions_config_community_tweet_member: {\n\t\t\t\t\tvalue: [\"embed\", \"pin_to_profile\", \"retweet\", \"highlight\"],\n\t\t\t\t},\n\t\t\t\ttweet_limited_actions_config_community_tweet_member_removed: {\n\t\t\t\t\tvalue: [\n\t\t\t\t\t\t\"add_to_bookmarks\",",
"score": 0.743716835975647
}
] | typescript | log(`"${tweet.full_text}"`); |
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/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": 0.808827817440033
},
{
"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": 0.7976748943328857
},
{
"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": 0.7953752279281616
},
{
"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": 0.7894922494888306
},
{
"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": 0.7851390242576599
}
] | typescript | await this.actionHandler.handle(this.id, result.action); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.