system

Abstract

Provide a system. [Solution] A means of obtaining the difference of the changes; A means of analyzing the changed file names from the obtained diff; A means for generating a commit message based on the parsed filename; A means for committing to a version control system using the generated commit message; A system including:

Description

[Technical Field]

[0001] The technology of the present disclosure relates to a system. [Background technology]

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] In software development, developers are required to create appropriate commit messages when committing changes using a version control system. However, creating appropriate messages requires time and effort, which is particularly troublesome when development speed is a priority. In addition, if appropriate messages are not created, repository management becomes difficult, making it difficult for other developers to understand the changes. Therefore, the present invention aims to solve these problems by providing a system that reduces the burden on developers and automatically generates appropriate commit messages efficiently. [Means for solving the problem]

[0005] The present invention solves the above-mentioned problems by providing a system that includes a means for acquiring the differences of changes, a means for analyzing changed file names from the acquired differences, a means for generating a commit message based on the analyzed file names, and a means for committing to a version control system using the generated commit message. This system allows developers to automatically acquire the differences of changes and automatically generate appropriate commit messages, significantly reducing the effort required for message creation. Furthermore, by providing a means for notifying the developer that there are no changes when the acquired differences do not exist, it is possible to prevent unnecessary commit operations. Furthermore, by analyzing the acquired differences using regular expressions, changed file names can be extracted efficiently and accurately.

[0006] The "difference of changes" is information indicating the difference between the previous state and the current state of a file staged in a version control system.

[0007] "Means for obtaining differences" refers to a function that executes operations in the version control system and obtains differences in the changes.

[0008] "Changed filename" refers to the name of the file that was actually changed in the staged changes.

[0009] "Means for analyzing" refers to the function of extracting necessary information from the acquired differences and processing them based on specific patterns.

[0010] A "commit message" is a string of characters used in a version control system to explain the content and reason for a file change.

[0011] "Means of generation" refers to the ability to create new data or information (here, commit messages) based on specific logic.

[0012] A "version control system" is a software system for recording and managing the change history of digital assets, including source code.

[0013] "Means for committing" refers to the ability to send changes and corresponding commit messages to a version control system.

[0014] "Means for notifying" refers to a function that notifies the user of information when a specific state or condition is met.

[0015] A "regular expression" is a notation for defining string patterns and for searching, analyzing, and replacing strings based on those patterns. [Brief explanation of the drawings]

[0016] [Figure 1] 1 is a conceptual diagram showing an example of the configuration of a data processing system according to a first embodiment. [Figure 2] 1 is a conceptual diagram showing an example of main functions of a data processing device and a smart device according to a first embodiment. [Figure 3] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a second embodiment. [Figure 4] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and smart glasses according to a second embodiment. [Figure 5] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a third embodiment. [Figure 6] FIG. 11 is a conceptual diagram showing an example of main functions of a data processing device and a headset-type terminal according to a third embodiment. [Figure 7] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a fourth embodiment. [Figure 8] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and a robot according to a fourth embodiment. [Figure 9] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 10]1 shows an emotion map onto which multiple emotions are mapped. [Figure 11] FIG. 3 is a sequence diagram illustrating a processing flow of the data processing system according to the first embodiment. [Figure 12] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1. [Figure 13] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system according to the second embodiment when an emotion engine is combined. [Figure 14] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 when an emotion engine is combined. DETAILED DESCRIPTION OF THE INVENTION

[0017] An example of an embodiment of a system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0018] First, the terms used in the following description will be explained.

[0019] In the following embodiments, a coded processor (hereinafter simply referred to as a "processor") may be a single arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be a single type of arithmetic device or a combination of multiple types of arithmetic devices. Examples of arithmetic devices include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), and an APU (Accelerated Processing Unit).

[0020] In the following embodiments, a coded RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a working memory by a processor.

[0021] In the following embodiments, the coded storage is one or more non-volatile storage devices that store various programs, various parameters, etc. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), and magnetic tapes.

[0022] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0023] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0024] [First embodiment]

[0025] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0026] 1, a data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0027] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0028] The smart device 14 includes a computer 36, a reception device 38, an output device 40, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The reception device 38, the output device 40, and the camera 42 are also connected to the bus 52.

[0029] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0030] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0031] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

[0032] FIG. 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0033] 2, in the data processing device 12, a specific process is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific process is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0034] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0035] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0036] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0037] This invention relates to a system for acquiring differences in changes, automatically generating commit messages, and performing commits in a version control system for software development. The system is composed of a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, and a means for performing commits.

[0038] Get diff

[0039] The server uses commands from the version control system to diff the staged changes, so that the server knows the difference between the current working directory and the most recent commit.

[0040] Filename Parsing

[0041] The server analyzes the changed file names based on the difference information it has acquired. This analysis uses a technique to extract specific patterns using regular expressions. Using regular expressions makes it possible to list the changed file names efficiently and accurately.

[0042] Generate a commit message

[0043] The server uses the parsed filenames to automatically generate appropriate commit messages, for example in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[0044] Performing a commit

[0045] The server executes the command containing the generated commit message to commit to the version control system, which stores the changes in the repository.

[0046] Specific examples

[0047] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0048] 1. Get diff: The server executes a specific command in the version control system to retrieve the staged changes and obtain the diff information.

[0049] 2. File analysis: The server analyzes the obtained difference information using regular expressions and extracts the changed file names "hello.py" and "README.md".

[0050] 3. Generate message: The server generates a commit message based on the extracted file names: "Changed files: hello.py, README.md".

[0051] 4. Perform the commit: Finally, the server commits the changes to the version control system using the generated commit message, which stores the changes in the repository with the appropriate message.

[0052] In this way, the present invention automatically analyzes changes and generates commit messages, eliminating the need for users to manually create messages. Furthermore, automating the analysis and generation process helps maintain consistent commit messages and improves repository management efficiency.

[0053] The processing flow will be explained below.

[0054] Step 1:

[0055] The server retrieves the changes in the version control system's staging area by running the version control system command git diff --cached, which retrieves a textual version control diff between the previous commit and the current staged state.

[0056] Step 2:

[0057] The server analyzes the difference information it has obtained and extracts the names of the changed files. To do this, the server uses the regular expression re.findall(r'diff --git a\ / (.?) ', diff) to extract the changed file names in the difference text. This extracts a list of file paths following "diff --git a / " from the difference text.

[0058] Step 3:

[0059] The server uses the extracted filenames to generate a commit message. At this stage, the server concatenates the listed filenames into a comma-separated string and creates a commit message containing that string. This message has the format "Changed files: [filename1], [filename2], ...".

[0060] Step 4:

[0061] The server uses the generated commit message to perform the commit to the version control system. The server runs the command git commit -m "generated commit message", which commits the staged changes to the repository.

[0062] Step 5:

[0063] The server will notify the user of the message after the commit. The server will display the message "Committed with message: [generated commit message]", which will allow the user to confirm that the commit was successful.

[0064] As described above, through this series of processes, the server obtains the difference between the changes, automatically generates an appropriate commit message, and commits it. This saves the user the trouble of creating a commit message, and improves the efficiency of repository management.

[0065] Example 1

[0066] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0067] In software development, manually reviewing changes and creating commit messages in version control systems is time-consuming, prone to inconsistency, and prone to human error. Generating appropriate commit messages also requires knowledge and experience, placing a burden on many developers. Furthermore, there is a need for a method to efficiently analyze the differences between changes and automatically generate commit messages.

[0068] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0069] In this invention, the server includes: means for acquiring differences between staged changes; means for analyzing changed file names from the acquired differences using regular expressions; means for generating a commit message in the format "Changed files: [file name]" based on the analyzed file names; and means for committing to the version control system using the generated commit message. This enables automatic analysis of changes and automatic generation of consistent commit messages, reducing the burden on users and preventing human error.

[0070] "Staging" is the process in a version control system of temporarily storing modified files in preparation for the next commit.

[0071] A "diff" is information indicating the changes between the contents of the current working directory and the contents that were previously committed.

[0072] A "regular expression" is an encoding rule that specifies a string pattern and allows you to search, extract, and replace strings that match that pattern.

[0073] A "commit message" is text in a version control system that explains the changes that have been made, and is information that is recorded together when a change is committed to a repository.

[0074] A "version control system" is a system used in software development to manage the change history of program code and documents and to enable multiple developers to work together.

[0075] A "repository" is a database in a version control system that records and stores the change history of files and data groups.

[0076] A "generative AI model" is an algorithmic model of artificial intelligence that learns from large amounts of data and automatically generates appropriate outputs for specific tasks.

[0077] This invention relates to a system that uses a version control system in software development to automatically obtain differences between changes, automatically generate commit messages, and execute commits. This system automates a series of processes centered on the server, reducing the user's workload and enabling the generation of consistent commit messages.

[0078] The system uses the following hardware and software:

[0079] 1. Hardware:

[0080] Server (a computer with a processor, memory, and storage)

[0081] 2. Software:

[0082] Version control system (e.g. Git)

[0083] Regular expression libraries (e.g. Perl compatible regular expressions)

[0084] Generative AI Models

[0085] Specific processing

[0086] Get the diff:

[0087] The server uses the version control system's commands (e.g. "git diff --staged") to get a diff of the staged changes, allowing the server to see the differences between the current working directory and the most recent commit.

[0088] Filename parsing:

[0089] The server analyzes the changed file names based on the difference information it has obtained using regular expressions. Specifically, it uses regular expressions (e.g., "^\+\+\+ b / (.$)") to efficiently extract the changed file names from the difference information.

[0090] Generate a commit message:

[0091] The server uses the parsed filenames to generate appropriate commit messages, in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[0092] Perform the commit:

[0093] The server commits the changes to the version control system by running a command (e.g., "git commit -m 'Changed files: hello.py, README.md'") with the generated commit message, which stores the changes properly in the repository.

[0094] Specific examples

[0095] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, running the system with these changes staged will perform the following actions:

[0096] 1. Get the diff:

[0097] The server runs "git diff --staged" to obtain the difference information between the staged "hello.py" and "README.md".

[0098] 2. File name analysis:

[0099] The server analyzes the difference information using regular expressions and extracts "hello.py" and "README.md" as changed file names.

[0100] 3. Generate a commit message:

[0101] The server generates a commit message saying "Changed files: hello.py, README.md".

[0102] 4. Perform the commit:

[0103] The server executes the command "git commit -m 'Changed files: hello.py, README.md'" to commit the changes to the repository.

[0104] Prompt Sentence Examples

[0105] Below are some example prompts to input to a generative AI model:

[0106] A user creates a new file "hello.py" locally and updates the file "README.md". After staging this change, the server runs "git diff --staged" to obtain the difference information. The difference information is analyzed using regular expressions to extract "hello.py" and "README.md". Based on the extracted file names, a commit message "Changed files: hello.py, README.md" is generated, and this is committed to the repository by running the command "git commit -m 'Changed files: hello.py, README.md'".

[0107] Operating the system in this way allows for automated analysis of changes and generation of commit messages, reducing the burden on users and the risk of errors.

[0108] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0109] Processing flow

[0110] Step 1:

[0111] The server runs commands from your version control system (e.g. Git) to keep track of the changes you've made locally.

[0112] Specific behavior:

[0113] The server runs the "git diff --staged" command to get the diff information for the staged changes.

[0114] input:

[0115] Changes staged in a version control system.

[0116] Data processing and calculation:

[0117] Obtain difference information using the version control system command "git diff --staged".

[0118] output:

[0119] The diff information for the staged changes.

[0120] Step 2:

[0121] The server extracts the changed file name from the acquired difference information.

[0122] Specific behavior:

[0123] The server parses the diff information using a regular expression (e.g. "^\+\+\+ b / (.$)") and extracts the changed filenames.

[0124] input:

[0125] The difference information obtained in step 1.

[0126] Data processing and calculation:

[0127] Extract changed file names from difference information using text analysis with regular expressions.

[0128] output:

[0129] A list of the extracted modified filenames (e.g. "hello.py" "README.md").

[0130] Step 3:

[0131] The server generates an appropriate commit message based on the extracted filename.

[0132] Specific behavior:

[0133] The server uses the parsed filename to generate a commit message of the form "Changed files: [filename]".

[0134] input:

[0135] The renamed filename extracted in step 2.

[0136] Data processing and calculation:

[0137] A string formatter to generate a commit message based on the extracted filename.

[0138] output:

[0139] The generated commit message (e.g., "Changed files: hello.py, README.md").

[0140] Step 4:

[0141] The server executes a commit to the version control system using the generated commit message.

[0142] Specific behavior:

[0143] The server runs the command "git commit -m 'Changed files: hello.py, README.md'" to save the changes to the repository.

[0144] input:

[0145] The commit message generated in step 3.

[0146] Data processing and calculation:

[0147] Executes a commit command to the version control system.

[0148] output:

[0149] The changes have been committed to the repository.

[0150] These steps allow the server to automatically analyze the changes, generate appropriate commit messages, and commit them to the version control system, saving users the trouble of manually reviewing the changes and creating commit messages.

[0151] (Application example 1)

[0152] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0153] Currently, software updates for factory robots are often managed manually, resulting in time-consuming and labor-intensive update tasks and a high risk of human error. Furthermore, updates are often recorded inconsistently, making maintenance and troubleshooting difficult. The present invention addresses these issues by providing a system for automatic software update management.

[0154] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0155] In this invention, the server includes means for acquiring differences in the changes, means for analyzing the changed file names, means for generating a commit message based on the analyzed file names, means for committing to the version control system using the generated commit message, and means for saving the generated commit message in a repository as changes to the software installed in the control unit of the factory robot. This automates software update management for the factory robot, enabling consistent update records and efficient maintenance.

[0156] The "diff of changes" is the difference between the changes staged in the version control system and the changes that were previously committed.

[0157] "File name analysis" is the process of identifying the names of files that have been changed from the acquired differences.

[0158] A "commit message" is a brief message in a version control system that explains the changes.

[0159] A "version control system" is a system that manages the change history of software source code and documents.

[0160] A "factory robot" is a mechanical device used to automate tasks in the manufacturing industry.

[0161] "Control Unit" means a hardware or software component that operates and controls a factory robot.

[0162] A "repository" is a place within a version control system that stores the version history of files.

[0163] This invention is a system that automates software update management for factory robots, obtaining the differences in changes, automatically generating commit messages, and appropriately recording and applying the changes to the control units of the factory robots.

[0164] The server first uses a version control system (e.g., Git) to obtain a diff of the staged changes, which gives the difference between the current working directory and the most recent commit. The server then uses regular expressions to parse the resulting diff for changed filenames. This parsing process results in a list of all changed filenames.

[0165] Next, the server automatically generates an appropriate commit message based on the filename obtained through the analysis. This message uses the format "Changed files: [filename]" so that anyone can understand the changes at a glance. The server then uses the generated commit message to execute a commit to the version control system, and the changes are saved in the repository.

[0166] Furthermore, the server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot. Based on the information stored in this repository, the software of the factory robot is automatically updated.

[0167] For example, if a user creates a new "robot_control.py" file and updates an existing "config.yaml" file in a factory control unit, running the system with these changes staged in a version control system will result in the following behavior:

[0168] 1. The server executes a specific command in the version control system to retrieve the staged changes and obtain the difference information.

[0169] 2. Next, the server analyzes the acquired difference information using regular expressions and extracts the changed file names "robot_control.py" and "config.yaml".

[0170] 3. The server generates a commit message based on the extracted file names: "Changed files: robot_control.py, config.yaml".

[0171] 4. Using this commit message, the server commits the changes to the version control system.

[0172] 5. Finally, the server stores the generated commit message in the repository as a change to the software installed in the control unit of the factory robot.

[0173] In this way, the system according to the present invention makes software update management in factory automation processes more efficient, consistent, and reliable.

[0174] Example of an input prompt for a generative AI model:

[0175] "Design a system to automatically version control changes to software installed on the control units of factory robots. The system will include functionality to obtain diffs, parse filenames, generate commit messages, and execute commits. Please also provide a Python script for each function."

[0176] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0177] Step 1:

[0178] The server executes version control system commands to obtain the diff of the staged changes.

[0179] Specifically, it executes the Git command "git diff --staged" and obtains its output in text format. The input is the Git command with the "--staged" option, and the output is text of the difference information for the staged files.

[0180] Step 2:

[0181] The server analyzes the acquired difference information and lists the changed file names.

[0182] Specifically, it extracts file names from the difference information using regular expressions. The input is the text of the difference information obtained in step 1, and the output is a list of changed file names.

[0183] Step 3:

[0184] The server will automatically generate a commit message based on the name of the file that was changed.

[0185] Specifically, it creates a message in the format "Changed files: [filename]", where the input is the list of filenames obtained in step 2, and the output is the text of the generated commit message.

[0186] Step 4:

[0187] The server commits the changes to the version control system using the generated commit message.

[0188] Specifically, it runs the Git command "git commit -m [commit message]", where the input is the commit message text generated in step 3, and the output is a success or failure message.

[0189] Step 5:

[0190] The server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot.

[0191] Specifically, the robot control software repository is updated. The input is the text of the commit message generated in step 3, and the output is a message resulting from the update to the repository.

[0192] Furthermore, an emotion engine that estimates the user's emotion may be combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59 and perform identification processing using the user's emotion.

[0193] The present invention relates to a system that acquires differences between changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing user emotions when using a version control system in software development. The system includes a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, a means for committing, and an emotion engine that recognizes user emotions.

[0194] Get diff

[0195] The server uses version control system commands to diff the staged changes, so that the server knows the differences between the current working directory and the most recent commit.

[0196] Filename Parsing

[0197] The server analyzes the changed file names based on the difference information it has obtained, using regular expressions to efficiently and accurately list the changed file names.

[0198] Generate a commit message

[0199] The server generates a commit message based on the parsed filenames, in the format "Changed files: [filename1], [filename2], ...".

[0200] Emotional engine regulation

[0201] The server recognizes the user's emotions using an emotion engine. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to identify the user's emotional state. The server adjusts the commit message based on this emotional information.

[0202] For example, if a user is in a stressful state, the server can soften the tone of the commit message and add an encouraging message, such as "Changed files: hello.py, README.md. Take a break, you're doing great!" Conversely, if a user is in a positive emotional state, it can add positive comments to the commit message.

[0203] Performing a commit

[0204] The server uses the generated commit message to perform a commit to the version control system, which stores the changes in the repository.

[0205] Specific examples

[0206] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0207] 1. Get diff: The server runs the git diff --cached command to get the diff of the staged changes.

[0208] 2. File name analysis: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[0209] 3. Generate a message: The server generates a message in the format "Changed files: hello.py, README.md".

[0210] 4. Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[0211] 5. Perform the commit: The server performs the commit to the version control system using the generated commit message.

[0212] 6. Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0213] In this way, the present invention automatically analyzes changes, automatically generates appropriate commit messages, and adjusts messages according to the user's feelings, thereby improving user work efficiency and the quality of repository management.

[0214] The processing flow will be explained below.

[0215] Step 1:

[0216] The server retrieves the changes from the staging area of ​​the version control system by running the git diff --cached command and receiving the diff information in text format on standard output, including the names of the changed files and details of the changes.

[0217] Step 2:

[0218] The server analyzes the difference information and extracts the changed file names. The server uses a regular expression to identify the file path following "diff --git a / " in the difference text. This extracts the changed file names in a list format.

[0219] Step 3:

[0220] The server generates the initial commit message based on the extracted filenames. The server concatenates the listed filenames into a comma-separated string to form a commit message of the form "Changed files: [filename1], [filename2], ...".

[0221] Step 4:

[0222] The server uses an emotion engine to recognize the user's emotions. The emotion engine analyzes the user's input and biometric information (e.g., voice tone and facial expression data) to identify the emotional state the user is experiencing. For example, it determines whether the user is feeling stressed through voice input or facial recognition.

[0223] Step 5:

[0224] The server adjusts the initial commit message based on the user's perceived emotions. For example, if the server determines that the user is stressed, it adds encouraging words like "Keep up the great work!" to the message. Conversely, if the user is experiencing positive emotions, it adds positive comments like "Excellent progress!".

[0225] Step 6:

[0226] The server uses the generated commit message to execute a commit to the version control system, specifically by running the git commit -m "generated commit message" command, which commits the staged changes to the repository.

[0227] Step 7:

[0228] The server notifies the user that the commit is complete. The server displays the message "Committed with message: [generated commit message]" on the terminal, allowing the user to confirm that the commit was successful.

[0229] By following these steps, users can automatically obtain the difference between changes and efficiently commit using appropriately adjusted commit messages. This series of processes saves users the trouble of creating commit messages and improves work efficiency.

[0230] Example 2

[0231] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0232] Version control systems in modern software development are required to efficiently manage changes and generate appropriate commit messages. However, manually creating commit messages can be error-prone and can be stressful due to the user's emotional state. This can lead to problems such as reduced work efficiency and a decline in the quality of repository management. There is a need to solve this issue and provide a system that generates highly accurate commit messages and takes user emotions into consideration.

[0233] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0234] In this invention, the server includes a means for acquiring the difference of the changes, a means for analyzing the changed file names from the acquired difference, a means for generating a commit message based on the analyzed file names, a means for recognizing the emotional state of the user and adjusting the commit message, and a means for committing to the version control system using the generated commit message. This makes it possible to efficiently manage the changes and generate an appropriate commit message according to the emotional state of the user.

[0235] The "diff of changes" is information that indicates the difference between the current working directory and the contents that were previously committed.

[0236] "File name analysis" is the process of identifying changed file names from the difference information.

[0237] A "commit message" is a message that clearly describes the changes and is used when committing them to a version control system.

[0238] The "user's emotional state" is information that indicates the user's current emotional state, and is a state that is recognized by analyzing input and biometric information.

[0239] The "changed file name" is the name of the file that was changed in the version control system.

[0240] An "emotion engine" is a system that analyzes and recognizes a user's emotional state based on their input and biometric information.

[0241] A "version control system" is a system for managing versions of software source code, documents, etc., and tracking change history and branching.

[0242] "Commit" is the operation of registering changes in a repository and saving them in a version control system.

[0243] "Staging" is the process of preparing changes for subsequent commit.

[0244] The present invention relates to a system that, when using a version control system in software development, acquires differences in changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing the user's emotions. The system includes means for acquiring differences in changes, means for analyzing changed file names from the acquired differences, means for generating a commit message based on the analyzed file names, means for adjusting the commit message by recognizing the user's emotional state, and means for committing to the version control system using the generated commit message.

[0245] Get diff

[0246] The server uses commands from the version control system to obtain the differences between the staged changes. Specifically, the server runs the git diff --cached command to determine the differences between the current working directory and the most recently committed content. By obtaining this difference information, the server can accurately identify the file names and changes required for the next process.

[0247] Filename Parsing

[0248] The server analyzes the changed file names based on the difference information it has obtained. Regular expressions are used for this analysis. By using regular expressions, it is possible to efficiently and accurately list the changed file names from the difference information. The listed file names are used to generate the next commit message.

[0249] Generate a commit message

[0250] The server generates a commit message based on the parsed filenames. The generated message is in the format "Changed files: [filename1], [filename2], ...". This makes it easy to see at a glance who changed which files.

[0251] Emotional engine regulation

[0252] The server uses an emotion engine to recognize the user's emotional state. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to determine the user's emotion. The server adjusts the commit message based on this emotional information. For example, if the user is in a stressful state, the server can add an encouraging comment to the commit message. As a specific example, it can generate an adjusted message such as "Changed files: hello.py, README.md. Keep up the great work!"

[0253] Performing a commit

[0254] The server uses the generated commit message to execute a commit to the version control system, which saves the changes to the repository. The server executes the commit using the git commit -m "generated commit message" command.

[0255] Specific examples

[0256] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0257] Diff: The server runs the git diff --cached command to get the diff of the staged changes.

[0258] Filename parsing: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[0259] Generate a commit message: The server generates a message in the format "Changed files: hello.py, README.md".

[0260] Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[0261] Perform the commit: The server performs the commit to the version control system using the generated commit message.

[0262] Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0263] This system automatically generates appropriate commit messages, improving user work efficiency while enabling messages to be adjusted according to emotional fluctuations.

[0264] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0265] Step 1: Get the diff

[0266] The server uses commands from the version control system to get the diff of the staged changes. Specifically, the server runs the git diff --cached command to get the difference between the current working directory and the most recently committed content. The diff information is the input, and the output is the diff data as a comparison result.

[0267] Specific behavior:

[0268] The server runs the git diff --cached command to get the diffs of the changed files, which are temporarily stored in memory.

[0269] Step 2: Parsing the filename

[0270] Analyzes the changed file names based on the difference information obtained from the server. The input is the difference information and the output is a list of changed file names. Regular expressions are used for this analysis.

[0271] Specific behavior:

[0272] The server analyzes the diff information and applies regular expressions to extract the changed filenames, which are organized into a list and stored in memory.

[0273] Step 3: Generate a commit message

[0274] The server generates a commit message based on the parsed filenames. The input is a list of changed filenames, and the output is the commit message. The generated message is in the format "Changed files: [filename1], [filename2], ...".

[0275] Specific behavior:

[0276] The server reads the list of filenames and uses them to construct a commit message in the specified format, which is then stored in memory.

[0277] Step 4: Emotional Engine Adjustment

[0278] The server uses an emotion engine to recognize the user's emotional state. The input is the user's input and biometric information, and the output is a commit message that reflects the user's emotional state. The emotion engine performs analysis and identifies the user's emotion.

[0279] Specific behavior:

[0280] 1. The server launches the emotion engine and collects user input (e.g., keyboard typing speed, mouse movements) and biometric information (e.g., tone of voice, facial expression data).

[0281] 2. The emotion engine analyzes the collected data and determines the user's emotional state.

[0282] 3. The server adjusts the commit message based on this emotional information, for example adding an encouraging message like "Keep up the great work!" if the user is stressed.

[0283] Step 5: Performing a Commit

[0284] The server uses the generated commit message to execute a commit into the version control system. The input is the commit message, and the output is the changes reflected in the repository.

[0285] Specific behavior:

[0286] The server executes the git commit -m "generated commit message" command, saving the changes to the repository. Verify that the commit was successful.

[0287] Step 6: Message Notification

[0288] The server notifies the user with a successful commit message. The input is the status that the commit was successful, and the output is a notification message to the user.

[0289] Specific behavior:

[0290] 1. The server generates a commit success message and sends a notification to the user's device.

[0291] 2. The user will see the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0292] (Application example 2)

[0293] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0294] In software development, when properly obtaining the difference between changes and generating commit messages, the process is mechanically performed without considering the user's feelings, which can lead to a problem of reduced work efficiency depending on the user's psychological state. In particular, there is a problem that processing monotonous commit messages under stress reduces motivation, resulting in a decline in work efficiency.

[0295] The specification process by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring differences in changes, means for analyzing the changed data from the acquired differences, means for generating a commit message based on the analyzed data, means for adjusting the commit message using an emotion engine that recognizes the user's emotions, and means for committing to the data management system using the generated commit message. This makes it possible to automatically analyze changes and automatically generate appropriate commit messages, as well as adjust the message according to the user's emotions, thereby improving user work efficiency and the quality of repository management.

[0296] The "means for obtaining the difference of the changes" is a means for detecting and recording the changes newly made in the software repository.

[0297] The "means for analyzing changed data" is a means for automatically analyzing and identifying affected files and data based on the acquired difference information.

[0298] The "means for generating a commit message" is a means for automatically creating a commit message in a format that is easy for a user to understand, based on the analyzed data.

[0299] An "emotion engine" is software or hardware that analyzes a user's facial expressions, voice, input data, etc., and identifies the user's emotional state.

[0300] The "means for adjusting a commit message" refers to a means for appropriately changing the tone and content of the generated commit message depending on the emotional state of the user identified by the emotion engine.

[0301] A "data management system" is a system that primarily manages the versioning of software repositories, and its purpose is to store, manage, and share change histories.

[0302] This invention is a system for supporting software update management for factory robots, in which a server obtains the differences in changes, analyzes the changed data, generates a commit message, recognizes the user's emotions, adjusts the commit message, and commits it.

[0303] The server uses the following hardware and software. The hardware includes a basic server environment, a smartphone, a head-mounted display, a microphone, a camera, etc. The software uses PyGit2 for operating the Git repository, Google (registered trademark) Speech Recognition API for voice recognition, EmotionRecognizer for emotion recognition, and gTTS for text-to-speech synthesis.

[0304] The server first retrieves the diffs of the factory robot's software changes from the Git repository, allowing the server to understand what new changes have been made. The diff information is then parsed using regular expressions to automatically identify which files have changed.

[0305] The server then generates a commit message based on the retrieved diff information, which has the format "Modified files: [filename1], [filename2], ..." But the key here is that the server is aware of the user's emotional state and adjusts the message accordingly.

[0306] To recognize the user's emotional state, voice input and facial expression data are used. When the user inputs commands into the microphone, the server converts the voice commands into text data using the Google Speech Recognition API. Furthermore, it uses EmotionRecognizer to analyze the user's emotions and adjusts the content of the commit message depending on whether the user is in a stressful or positive state. For example, if the user is in a stressful state, a message such as "Good luck, good job!" is added.

[0307] Finally, the server executes the commit to the Git repository using the generated commit message. After the commit process is successful, the result is notified by voice. The server uses gTTS to synthesize the commit result and notify the user.

[0308] As a concrete example, consider the case where a user modifies "controller.py" and "sensor_data.py" while updating a robot's software. If the user speaks into the microphone and says "Please commit," the system recognizes the voice and determines that the user is stressed. In this case, it generates an encouraging message such as "Modified files: controller.py, sensor_data.py. Keep up the great work!" and executes the commit.

[0309] An example of a prompt is "Get the diff to commit and analyze the changed file names. Analyze the user's sentiment from the voice input and adjust the commit message." For example, it is executed by the voice input "Please commit."

[0310] In this way, the present invention realizes automatic analysis of changes in software management of factory robots, generation of appropriate commit messages, and adjustment of messages according to user emotions, thereby improving work efficiency and management quality.

[0311] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0312] Step 1:

[0313] The server retrieves the diff of changes from the Git repository, specifically by running the git diff --cached command to retrieve the staged changes. The input is the Git repository with the staged changes, and the output is the diff information.

[0314] Step 2:

[0315] The server analyzes the changed data based on the difference information it has acquired. It analyzes the difference information using regular expressions and extracts the changed file names. The input is the difference information, and the output is a list of changed file names.

[0316] Step 3:

[0317] The server generates a commit message based on the parsed file names. For example, if the changed file names are "controller.py" and "sensor_data.py", it generates a message of the form "Changed files: controller.py, sensor_data.py". The input is a list of changed file names, and the output is a basic commit message.

[0318] Step 4:

[0319] The user inputs voice instructions into the microphone to adjust the commit message, and the server converts the speech to text data using the Google Speech Recognition API. The input is the user's voice instructions, and the output is text data.

[0320] Step 5:

[0321] The server identifies the user's emotional state based on the text data of the voice instructions. It uses EmotionRecognizer to analyze the text data and determine whether the user is in a stressful or positive state. The input is the text data of the voice instructions, and the output is the user's emotional state.

[0322] Step 6:

[0323] The server adjusts the commit message according to the perceived emotional state, for example, if the user is stressed, it adds an encouraging message such as "Keep up the good work, good job!" The input is a basic commit message and the user's emotional state, and the output is the adjusted commit message.

[0324] Step 7:

[0325] The server executes the commit to the Git repository using the adjusted commit message. It executes the git commit command using the generated commit message. The input is the adjusted commit message, and the output is a notification of the success of the commit operation.

[0326] Step 8:

[0327] The server notifies the user of the result of the commit process. It uses gTTS to synthesize the commit result and notifies the user by voice. The input is a notification of the success of the commit process, and the output is a voice notification of the commit result.

[0328] In this way, the server automatically analyzes changes in software management of factory robots, automatically generates commit messages, adjusts messages according to the user's emotions, and provides audio notification of the commit contents.

[0329] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0330] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0331] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0332] [Second embodiment]

[0333] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0334] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0335] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0336] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, and the camera 42 are also connected to the bus 52.

[0337] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0338] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0339] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0340] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0341] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0342] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0343] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0344] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal."

[0345] This invention relates to a system for acquiring differences in changes, automatically generating commit messages, and performing commits in a version control system for software development. The system is composed of a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, and a means for performing commits.

[0346] Get diff

[0347] The server uses commands from the version control system to diff the staged changes, so that the server knows the difference between the current working directory and the most recent commit.

[0348] Filename Parsing

[0349] The server analyzes the changed file names based on the difference information it has acquired. This analysis uses a technique to extract specific patterns using regular expressions. Using regular expressions makes it possible to list the changed file names efficiently and accurately.

[0350] Generate a commit message

[0351] The server uses the parsed filenames to automatically generate appropriate commit messages, for example in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[0352] Performing a commit

[0353] The server executes the command containing the generated commit message to commit to the version control system, which stores the changes in the repository.

[0354] Specific examples

[0355] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0356] 1. Get diff: The server executes a specific command in the version control system to retrieve the staged changes and obtain the diff information.

[0357] 2. File analysis: The server analyzes the obtained difference information using regular expressions and extracts the changed file names "hello.py" and "README.md".

[0358] 3. Generate message: The server generates a commit message based on the extracted file names: "Changed files: hello.py, README.md".

[0359] 4. Perform the commit: Finally, the server commits the changes to the version control system using the generated commit message, which stores the changes in the repository with the appropriate message.

[0360] In this way, the present invention automatically analyzes changes and generates commit messages, eliminating the need for users to manually create messages. Furthermore, automating the analysis and generation process helps maintain consistent commit messages and improves repository management efficiency.

[0361] The processing flow will be explained below.

[0362] Step 1:

[0363] The server retrieves the changes in the version control system's staging area by running the version control system command git diff --cached, which retrieves a textual version control diff between the previous commit and the current staged state.

[0364] Step 2:

[0365] The server analyzes the difference information it has obtained and extracts the names of the changed files. To do this, the server uses the regular expression re.findall(r'diff --git a\ / (.?) ', diff) to extract the changed file names in the difference text. This extracts a list of file paths following "diff --git a / " from the difference text.

[0366] Step 3:

[0367] The server uses the extracted filenames to generate a commit message. At this stage, the server concatenates the listed filenames into a comma-separated string and creates a commit message containing that string. This message has the format "Changed files: [filename1], [filename2], ...".

[0368] Step 4:

[0369] The server uses the generated commit message to perform the commit to the version control system. The server runs the command git commit -m "generated commit message", which commits the staged changes to the repository.

[0370] Step 5:

[0371] The server will notify the user of the message after the commit. The server will display the message "Committed with message: [generated commit message]", which will allow the user to confirm that the commit was successful.

[0372] As described above, through this series of processes, the server obtains the difference between the changes, automatically generates an appropriate commit message, and commits it. This saves the user the trouble of creating a commit message, and improves the efficiency of repository management.

[0373] Example 1

[0374] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0375] In software development, manually reviewing changes and creating commit messages in version control systems is time-consuming, prone to inconsistency, and prone to human error. Generating appropriate commit messages also requires knowledge and experience, placing a burden on many developers. Furthermore, there is a need for a method to efficiently analyze the differences between changes and automatically generate commit messages.

[0376] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0377] In this invention, the server includes: means for acquiring differences between staged changes; means for analyzing changed file names from the acquired differences using regular expressions; means for generating a commit message in the format "Changed files: [file name]" based on the analyzed file names; and means for committing to the version control system using the generated commit message. This enables automatic analysis of changes and automatic generation of consistent commit messages, reducing the burden on users and preventing human error.

[0378] "Staging" is the process in a version control system of temporarily storing modified files in preparation for the next commit.

[0379] A "diff" is information indicating the changes between the contents of the current working directory and the contents that were previously committed.

[0380] A "regular expression" is an encoding rule that specifies a string pattern and allows you to search, extract, and replace strings that match that pattern.

[0381] A "commit message" is text in a version control system that explains the changes that have been made, and is information that is recorded together when a change is committed to a repository.

[0382] A "version control system" is a system used in software development to manage the change history of program code and documents and to enable multiple developers to work together.

[0383] A "repository" is a database in a version control system that records and stores the change history of files and data groups.

[0384] A "generative AI model" is an algorithmic model of artificial intelligence that learns from large amounts of data and automatically generates appropriate outputs for specific tasks.

[0385] This invention relates to a system that uses a version control system in software development to automatically obtain differences between changes, automatically generate commit messages, and execute commits. This system automates a series of processes centered on the server, reducing the user's workload and enabling the generation of consistent commit messages.

[0386] The system uses the following hardware and software:

[0387] 1. Hardware:

[0388] Server (a computer with a processor, memory, and storage)

[0389] 2. Software:

[0390] Version control system (e.g. Git)

[0391] Regular expression libraries (e.g. Perl compatible regular expressions)

[0392] Generative AI Models

[0393] Specific processing

[0394] Get the diff:

[0395] The server uses the version control system's commands (e.g. "git diff --staged") to get a diff of the staged changes, allowing the server to see the differences between the current working directory and the most recent commit.

[0396] Filename parsing:

[0397] The server analyzes the changed file names based on the difference information it has obtained using regular expressions. Specifically, it uses regular expressions (e.g., "^\+\+\+ b / (.$)") to efficiently extract the changed file names from the difference information.

[0398] Generate a commit message:

[0399] The server uses the parsed filenames to generate appropriate commit messages, in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[0400] Perform the commit:

[0401] The server commits the changes to the version control system by running a command (e.g., "git commit -m 'Changed files: hello.py, README.md'") with the generated commit message, which stores the changes properly in the repository.

[0402] Specific examples

[0403] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, running the system with these changes staged will perform the following actions:

[0404] 1. Get the diff:

[0405] The server runs "git diff --staged" to obtain the difference information between the staged "hello.py" and "README.md".

[0406] 2. File name analysis:

[0407] The server analyzes the difference information using regular expressions and extracts "hello.py" and "README.md" as changed file names.

[0408] 3. Generate a commit message:

[0409] The server generates a commit message saying "Changed files: hello.py, README.md".

[0410] 4. Perform the commit:

[0411] The server executes the command "git commit -m 'Changed files: hello.py, README.md'" to commit the changes to the repository.

[0412] Prompt Sentence Examples

[0413] Below are some example prompts to input to a generative AI model:

[0414] A user creates a new file "hello.py" locally and updates the file "README.md". After staging this change, the server runs "git diff --staged" to obtain the difference information. The difference information is analyzed using regular expressions to extract "hello.py" and "README.md". Based on the extracted file names, a commit message "Changed files: hello.py, README.md" is generated, and this is committed to the repository by running the command "git commit -m 'Changed files: hello.py, README.md'".

[0415] Operating the system in this way allows for automated analysis of changes and generation of commit messages, reducing the burden on users and the risk of errors.

[0416] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0417] Processing flow

[0418] Step 1:

[0419] The server runs commands from your version control system (e.g. Git) to keep track of the changes you've made locally.

[0420] Specific behavior:

[0421] The server runs the "git diff --staged" command to get the diff information for the staged changes.

[0422] input:

[0423] Changes staged in a version control system.

[0424] Data processing and calculation:

[0425] Obtain difference information using the version control system command "git diff --staged".

[0426] output:

[0427] The diff information for the staged changes.

[0428] Step 2:

[0429] The server extracts the changed file name from the acquired difference information.

[0430] Specific behavior:

[0431] The server parses the diff information using a regular expression (e.g. "^\+\+\+ b / (.$)") and extracts the changed filenames.

[0432] input:

[0433] The difference information obtained in step 1.

[0434] Data processing and calculation:

[0435] Extract changed file names from difference information using text analysis with regular expressions.

[0436] output:

[0437] A list of the extracted modified filenames (e.g. "hello.py" "README.md").

[0438] Step 3:

[0439] The server generates an appropriate commit message based on the extracted filename.

[0440] Specific behavior:

[0441] The server uses the parsed filename to generate a commit message of the form "Changed files: [filename]".

[0442] input:

[0443] The renamed filename extracted in step 2.

[0444] Data processing and calculation:

[0445] A string formatter to generate a commit message based on the extracted filename.

[0446] output:

[0447] The generated commit message (e.g., "Changed files: hello.py, README.md").

[0448] Step 4:

[0449] The server executes a commit to the version control system using the generated commit message.

[0450] Specific behavior:

[0451] The server runs the command "git commit -m 'Changed files: hello.py, README.md'" to save the changes to the repository.

[0452] input:

[0453] The commit message generated in step 3.

[0454] Data processing and calculation:

[0455] Executes a commit command to the version control system.

[0456] output:

[0457] The changes have been committed to the repository.

[0458] These steps allow the server to automatically analyze the changes, generate appropriate commit messages, and commit them to the version control system, saving users the trouble of manually reviewing the changes and creating commit messages.

[0459] (Application example 1)

[0460] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0461] Currently, software updates for factory robots are often managed manually, resulting in time-consuming and labor-intensive update tasks and a high risk of human error. Furthermore, updates are often recorded inconsistently, making maintenance and troubleshooting difficult. The present invention addresses these issues by providing a system for automatic software update management.

[0462] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0463] In this invention, the server includes means for acquiring differences in the changes, means for analyzing the changed file names, means for generating a commit message based on the analyzed file names, means for committing to the version control system using the generated commit message, and means for saving the generated commit message in a repository as changes to the software installed in the control unit of the factory robot. This automates software update management for the factory robot, enabling consistent update records and efficient maintenance.

[0464] The "diff of changes" is the difference between the changes staged in the version control system and the changes that were previously committed.

[0465] "File name analysis" is the process of identifying the names of files that have been changed from the acquired differences.

[0466] A "commit message" is a brief message in a version control system that explains the changes.

[0467] A "version control system" is a system that manages the change history of software source code and documents.

[0468] A "factory robot" is a mechanical device used to automate tasks in the manufacturing industry.

[0469] "Control Unit" means a hardware or software component that operates and controls a factory robot.

[0470] A "repository" is a place within a version control system that stores the version history of files.

[0471] This invention is a system that automates software update management for factory robots, obtaining the differences in changes, automatically generating commit messages, and appropriately recording and applying the changes to the control units of the factory robots.

[0472] The server first uses a version control system (e.g., Git) to obtain a diff of the staged changes, which gives the difference between the current working directory and the most recent commit. The server then uses regular expressions to parse the resulting diff for changed filenames. This parsing process results in a list of all changed filenames.

[0473] Next, the server automatically generates an appropriate commit message based on the filename obtained through the analysis. This message uses the format "Changed files: [filename]" so that anyone can understand the changes at a glance. The server then uses the generated commit message to execute a commit to the version control system, and the changes are saved in the repository.

[0474] Furthermore, the server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot. Based on the information stored in this repository, the software of the factory robot is automatically updated.

[0475] For example, if a user creates a new "robot_control.py" file and updates an existing "config.yaml" file in a factory control unit, running the system with these changes staged in a version control system will result in the following behavior:

[0476] 1. The server executes a specific command in the version control system to retrieve the staged changes and obtain the difference information.

[0477] 2. Next, the server analyzes the acquired difference information using regular expressions and extracts the changed file names "robot_control.py" and "config.yaml".

[0478] 3. The server generates a commit message based on the extracted file names: "Changed files: robot_control.py, config.yaml".

[0479] 4. Using this commit message, the server commits the changes to the version control system.

[0480] 5. Finally, the server stores the generated commit message in the repository as a change to the software installed in the control unit of the factory robot.

[0481] In this way, the system according to the present invention makes software update management in factory automation processes more efficient, consistent, and reliable.

[0482] Example of an input prompt for a generative AI model:

[0483] "Design a system to automatically version control changes to software installed on the control units of factory robots. The system will include functionality to obtain diffs, parse filenames, generate commit messages, and execute commits. Please also provide a Python script for each function."

[0484] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0485] Step 1:

[0486] The server executes version control system commands to obtain the diff of the staged changes.

[0487] Specifically, it executes the Git command "git diff --staged" and obtains its output in text format. The input is the Git command with the "--staged" option, and the output is text of the difference information for the staged files.

[0488] Step 2:

[0489] The server analyzes the acquired difference information and lists the changed file names.

[0490] Specifically, it extracts file names from the difference information using regular expressions. The input is the text of the difference information obtained in step 1, and the output is a list of changed file names.

[0491] Step 3:

[0492] The server will automatically generate a commit message based on the name of the file that was changed.

[0493] Specifically, it creates a message in the format "Changed files: [filename]", where the input is the list of filenames obtained in step 2, and the output is the text of the generated commit message.

[0494] Step 4:

[0495] The server commits the changes to the version control system using the generated commit message.

[0496] Specifically, it runs the Git command "git commit -m [commit message]", where the input is the commit message text generated in step 3, and the output is a success or failure message.

[0497] Step 5:

[0498] The server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot.

[0499] Specifically, the robot control software repository is updated. The input is the text of the commit message generated in step 3, and the output is a message resulting from the update to the repository.

[0500] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0501] The present invention relates to a system that acquires differences between changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing user emotions when using a version control system in software development. The system includes a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, a means for committing, and an emotion engine that recognizes user emotions.

[0502] Get diff

[0503] The server uses version control system commands to diff the staged changes, so that the server knows the differences between the current working directory and the most recent commit.

[0504] Filename Parsing

[0505] The server analyzes the changed file names based on the difference information it has obtained, using regular expressions to efficiently and accurately list the changed file names.

[0506] Generate a commit message

[0507] The server generates a commit message based on the parsed filenames, in the format "Changed files: [filename1], [filename2], ...".

[0508] Emotional engine regulation

[0509] The server recognizes the user's emotions using an emotion engine. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to identify the user's emotional state. The server adjusts the commit message based on this emotional information.

[0510] For example, if a user is in a stressful state, the server can soften the tone of the commit message and add an encouraging message, such as "Changed files: hello.py, README.md. Take a break, you're doing great!" Conversely, if a user is in a positive emotional state, it can add positive comments to the commit message.

[0511] Performing a commit

[0512] The server uses the generated commit message to perform a commit to the version control system, which stores the changes in the repository.

[0513] Specific examples

[0514] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0515] 1. Get diff: The server runs the git diff --cached command to get the diff of the staged changes.

[0516] 2. File name analysis: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[0517] 3. Generate a message: The server generates a message in the format "Changed files: hello.py, README.md".

[0518] 4. Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[0519] 5. Perform the commit: The server performs the commit to the version control system using the generated commit message.

[0520] 6. Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0521] In this way, the present invention automatically analyzes changes, automatically generates appropriate commit messages, and adjusts messages according to the user's feelings, thereby improving user work efficiency and the quality of repository management.

[0522] The processing flow will be explained below.

[0523] Step 1:

[0524] The server retrieves the changes from the staging area of ​​the version control system by running the git diff --cached command and receiving the diff information in text format on standard output, including the names of the changed files and details of the changes.

[0525] Step 2:

[0526] The server analyzes the difference information and extracts the changed file names. The server uses a regular expression to identify the file path following "diff --git a / " in the difference text. This extracts the changed file names in a list format.

[0527] Step 3:

[0528] The server generates the initial commit message based on the extracted filenames. The server concatenates the listed filenames into a comma-separated string to form a commit message of the form "Changed files: [filename1], [filename2], ...".

[0529] Step 4:

[0530] The server uses an emotion engine to recognize the user's emotions. The emotion engine analyzes the user's input and biometric information (e.g., voice tone and facial expression data) to identify the emotional state the user is experiencing. For example, it determines whether the user is feeling stressed through voice input or facial recognition.

[0531] Step 5:

[0532] The server adjusts the initial commit message based on the user's perceived emotions. For example, if the server determines that the user is stressed, it adds encouraging words like "Keep up the great work!" to the message. Conversely, if the user is experiencing positive emotions, it adds positive comments like "Excellent progress!".

[0533] Step 6:

[0534] The server uses the generated commit message to execute a commit to the version control system, specifically by running the git commit -m "generated commit message" command, which commits the staged changes to the repository.

[0535] Step 7:

[0536] The server notifies the user that the commit is complete. The server displays the message "Committed with message: [generated commit message]" on the terminal, allowing the user to confirm that the commit was successful.

[0537] By following these steps, users can automatically obtain the difference between changes and efficiently commit using appropriately adjusted commit messages. This series of processes saves users the trouble of creating commit messages and improves work efficiency.

[0538] Example 2

[0539] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0540] Version control systems in modern software development are required to efficiently manage changes and generate appropriate commit messages. However, manually creating commit messages can be error-prone and can be stressful due to the user's emotional state. This can lead to problems such as reduced work efficiency and a decline in the quality of repository management. There is a need to solve this issue and provide a system that generates highly accurate commit messages and takes user emotions into consideration.

[0541] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0542] In this invention, the server includes a means for acquiring the difference of the changes, a means for analyzing the changed file names from the acquired difference, a means for generating a commit message based on the analyzed file names, a means for recognizing the emotional state of the user and adjusting the commit message, and a means for committing to the version control system using the generated commit message. This makes it possible to efficiently manage the changes and generate an appropriate commit message according to the emotional state of the user.

[0543] The "diff of changes" is information that indicates the difference between the current working directory and the contents that were previously committed.

[0544] "File name analysis" is the process of identifying changed file names from the difference information.

[0545] A "commit message" is a message that clearly describes the changes and is used when committing them to a version control system.

[0546] The "user's emotional state" is information that indicates the user's current emotional state, and is a state that is recognized by analyzing input and biometric information.

[0547] The "changed file name" is the name of the file that was changed in the version control system.

[0548] An "emotion engine" is a system that analyzes and recognizes a user's emotional state based on their input and biometric information.

[0549] A "version control system" is a system for managing versions of software source code, documents, etc., and tracking change history and branching.

[0550] "Commit" is the operation of registering changes in a repository and saving them in a version control system.

[0551] "Staging" is the process of preparing changes for subsequent commit.

[0552] The present invention relates to a system that, when using a version control system in software development, acquires differences in changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing the user's emotions. The system includes means for acquiring differences in changes, means for analyzing changed file names from the acquired differences, means for generating a commit message based on the analyzed file names, means for adjusting the commit message by recognizing the user's emotional state, and means for committing to the version control system using the generated commit message.

[0553] Get diff

[0554] The server uses commands from the version control system to obtain the differences between the staged changes. Specifically, the server runs the git diff --cached command to determine the differences between the current working directory and the most recently committed content. By obtaining this difference information, the server can accurately identify the file names and changes required for the next process.

[0555] Filename Parsing

[0556] The server analyzes the changed file names based on the difference information it has obtained. Regular expressions are used for this analysis. By using regular expressions, it is possible to efficiently and accurately list the changed file names from the difference information. The listed file names are used to generate the next commit message.

[0557] Generate a commit message

[0558] The server generates a commit message based on the parsed filenames. The generated message is in the format "Changed files: [filename1], [filename2], ...". This makes it easy to see at a glance who changed which files.

[0559] Emotional engine regulation

[0560] The server uses an emotion engine to recognize the user's emotional state. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to determine the user's emotion. The server adjusts the commit message based on this emotional information. For example, if the user is in a stressful state, the server can add an encouraging comment to the commit message. As a specific example, it can generate an adjusted message such as "Changed files: hello.py, README.md. Keep up the great work!"

[0561] Performing a commit

[0562] The server uses the generated commit message to execute a commit to the version control system, which saves the changes to the repository. The server executes the commit using the git commit -m "generated commit message" command.

[0563] Specific examples

[0564] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0565] Diff: The server runs the git diff --cached command to get the diff of the staged changes.

[0566] Filename parsing: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[0567] Generate a commit message: The server generates a message in the format "Changed files: hello.py, README.md".

[0568] Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[0569] Perform the commit: The server performs the commit to the version control system using the generated commit message.

[0570] Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0571] This system automatically generates appropriate commit messages, improving user work efficiency while enabling messages to be adjusted according to emotional fluctuations.

[0572] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0573] Step 1: Get the diff

[0574] The server uses commands from the version control system to get the diff of the staged changes. Specifically, the server runs the git diff --cached command to get the difference between the current working directory and the most recently committed content. The diff information is the input, and the output is the diff data as a comparison result.

[0575] Specific behavior:

[0576] The server runs the git diff --cached command to get the diffs of the changed files, which are temporarily stored in memory.

[0577] Step 2: Parsing the filename

[0578] Analyzes the changed file names based on the difference information obtained from the server. The input is the difference information and the output is a list of changed file names. Regular expressions are used for this analysis.

[0579] Specific behavior:

[0580] The server analyzes the diff information and applies regular expressions to extract the changed filenames, which are organized into a list and stored in memory.

[0581] Step 3: Generate a commit message

[0582] The server generates a commit message based on the parsed filenames. The input is a list of changed filenames, and the output is the commit message. The generated message is in the format "Changed files: [filename1], [filename2], ...".

[0583] Specific behavior:

[0584] The server reads the list of filenames and uses them to construct a commit message in the specified format, which is then stored in memory.

[0585] Step 4: Emotional Engine Adjustment

[0586] The server uses an emotion engine to recognize the user's emotional state. The input is the user's input and biometric information, and the output is a commit message that reflects the user's emotional state. The emotion engine performs analysis and identifies the user's emotion.

[0587] Specific behavior:

[0588] 1. The server launches the emotion engine and collects user input (e.g., keyboard typing speed, mouse movements) and biometric information (e.g., tone of voice, facial expression data).

[0589] 2. The emotion engine analyzes the collected data and determines the user's emotional state.

[0590] 3. The server adjusts the commit message based on this emotional information, for example adding an encouraging message like "Keep up the great work!" if the user is stressed.

[0591] Step 5: Performing a Commit

[0592] The server uses the generated commit message to execute a commit into the version control system. The input is the commit message, and the output is the changes reflected in the repository.

[0593] Specific behavior:

[0594] The server executes the git commit -m "generated commit message" command, saving the changes to the repository. Verify that the commit was successful.

[0595] Step 6: Message Notification

[0596] The server notifies the user with a successful commit message. The input is the status that the commit was successful, and the output is a notification message to the user.

[0597] Specific behavior:

[0598] 1. The server generates a commit success message and sends a notification to the user's device.

[0599] 2. The user will see the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0600] (Application example 2)

[0601] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0602] In software development, when properly obtaining the difference between changes and generating commit messages, the process is mechanically performed without considering the user's feelings, which can lead to a problem of reduced work efficiency depending on the user's psychological state. In particular, there is a problem that processing monotonous commit messages under stress reduces motivation, resulting in a decline in work efficiency.

[0603] The specification process by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring differences in changes, means for analyzing the changed data from the acquired differences, means for generating a commit message based on the analyzed data, means for adjusting the commit message using an emotion engine that recognizes the user's emotions, and means for committing to the data management system using the generated commit message. This makes it possible to automatically analyze changes and automatically generate appropriate commit messages, as well as adjust the message according to the user's emotions, thereby improving user work efficiency and the quality of repository management.

[0604] The "means for obtaining the difference of the changes" is a means for detecting and recording the changes newly made in the software repository.

[0605] The "means for analyzing changed data" is a means for automatically analyzing and identifying affected files and data based on the acquired difference information.

[0606] The "means for generating a commit message" is a means for automatically creating a commit message in a format that is easy for a user to understand, based on the analyzed data.

[0607] An "emotion engine" is software or hardware that analyzes a user's facial expressions, voice, input data, etc., and identifies the user's emotional state.

[0608] The "means for adjusting a commit message" refers to a means for appropriately changing the tone and content of the generated commit message depending on the emotional state of the user identified by the emotion engine.

[0609] A "data management system" is a system that primarily manages the versioning of software repositories, and its purpose is to store, manage, and share change histories.

[0610] This invention is a system for supporting software update management for factory robots, in which a server obtains the differences in changes, analyzes the changed data, generates a commit message, recognizes the user's emotions, adjusts the commit message, and commits it.

[0611] The server uses the following hardware and software: The hardware includes a basic server environment, a smartphone, a head-mounted display, a microphone, a camera, etc. The software uses PyGit2 for operating Git repositories, Google Speech Recognition API for voice recognition, EmotionRecognizer for emotion recognition, and gTTS for text-to-speech synthesis.

[0612] The server first retrieves the diffs of the factory robot's software changes from the Git repository, allowing the server to understand what new changes have been made. The diff information is then parsed using regular expressions to automatically identify which files have changed.

[0613] The server then generates a commit message based on the retrieved diff information, which has the format "Modified files: [filename1], [filename2], ..." But the key here is that the server is aware of the user's emotional state and adjusts the message accordingly.

[0614] To recognize the user's emotional state, voice input and facial expression data are used. When the user inputs commands into the microphone, the server converts the voice commands into text data using the Google Speech Recognition API. Furthermore, it uses EmotionRecognizer to analyze the user's emotions and adjusts the content of the commit message depending on whether the user is in a stressful or positive state. For example, if the user is in a stressful state, a message such as "Good luck, good job!" is added.

[0615] Finally, the server executes the commit to the Git repository using the generated commit message. After the commit process is successful, the result is notified by voice. The server uses gTTS to synthesize the commit result and notify the user.

[0616] As a concrete example, consider the case where a user modifies "controller.py" and "sensor_data.py" while updating a robot's software. If the user speaks into the microphone and says "Please commit," the system recognizes the voice and determines that the user is stressed. In this case, it generates an encouraging message such as "Modified files: controller.py, sensor_data.py. Keep up the great work!" and executes the commit.

[0617] An example of a prompt is "Get the diff to commit and analyze the changed file names. Analyze the user's sentiment from the voice input and adjust the commit message." For example, it is executed by the voice input "Please commit."

[0618] In this way, the present invention realizes automatic analysis of changes in software management of factory robots, generation of appropriate commit messages, and adjustment of messages according to user emotions, thereby improving work efficiency and management quality.

[0619] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0620] Step 1:

[0621] The server retrieves the diff of changes from the Git repository, specifically by running the git diff --cached command to retrieve the staged changes. The input is the Git repository with the staged changes, and the output is the diff information.

[0622] Step 2:

[0623] The server analyzes the changed data based on the difference information it has acquired. It analyzes the difference information using regular expressions and extracts the changed file names. The input is the difference information, and the output is a list of changed file names.

[0624] Step 3:

[0625] The server generates a commit message based on the parsed file names. For example, if the changed file names are "controller.py" and "sensor_data.py", it generates a message of the form "Changed files: controller.py, sensor_data.py". The input is a list of changed file names, and the output is a basic commit message.

[0626] Step 4:

[0627] The user inputs voice instructions into the microphone to adjust the commit message, and the server converts the speech to text data using the Google Speech Recognition API. The input is the user's voice instructions, and the output is text data.

[0628] Step 5:

[0629] The server identifies the user's emotional state based on the text data of the voice instructions. It uses EmotionRecognizer to analyze the text data and determine whether the user is in a stressful or positive state. The input is the text data of the voice instructions, and the output is the user's emotional state.

[0630] Step 6:

[0631] The server adjusts the commit message according to the perceived emotional state, for example, if the user is stressed, it adds an encouraging message such as "Keep up the good work, good job!" The input is a basic commit message and the user's emotional state, and the output is the adjusted commit message.

[0632] Step 7:

[0633] The server executes the commit to the Git repository using the adjusted commit message. It executes the git commit command using the generated commit message. The input is the adjusted commit message, and the output is a notification of the success of the commit operation.

[0634] Step 8:

[0635] The server notifies the user of the result of the commit process. It uses gTTS to synthesize the commit result and notifies the user by voice. The input is a notification of the success of the commit process, and the output is a voice notification of the commit result.

[0636] In this way, the server automatically analyzes changes in software management of factory robots, automatically generates commit messages, adjusts messages according to the user's emotions, and provides audio notification of the commit contents.

[0637] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0638] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0639] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[0640] [Third embodiment]

[0641] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[0642] 5, the data processing system 310 includes the data processing device 12 and a headset type terminal 314. An example of the data processing device 12 is a server.

[0643] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0644] The headset type terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a display 343. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the display 343 are also connected to the bus 52.

[0645] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0646] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0647] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0648] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0649] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0650] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0651] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0652] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the headset type terminal 314 will be referred to as the "terminal."

[0653] This invention relates to a system for acquiring differences in changes, automatically generating commit messages, and performing commits in a version control system for software development. The system is composed of a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, and a means for performing commits.

[0654] Get diff

[0655] The server uses commands from the version control system to diff the staged changes, so that the server knows the difference between the current working directory and the most recent commit.

[0656] Filename Parsing

[0657] The server analyzes the changed file names based on the difference information it has acquired. This analysis uses a technique to extract specific patterns using regular expressions. Using regular expressions makes it possible to list the changed file names efficiently and accurately.

[0658] Generate a commit message

[0659] The server uses the parsed filenames to automatically generate appropriate commit messages, for example in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[0660] Performing a commit

[0661] The server executes the command containing the generated commit message to commit to the version control system, which stores the changes in the repository.

[0662] Specific examples

[0663] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0664] 1. Get diff: The server executes a specific command in the version control system to retrieve the staged changes and obtain the diff information.

[0665] 2. File analysis: The server analyzes the obtained difference information using regular expressions and extracts the changed file names "hello.py" and "README.md".

[0666] 3. Generate message: The server generates a commit message based on the extracted file names: "Changed files: hello.py, README.md".

[0667] 4. Perform the commit: Finally, the server commits the changes to the version control system using the generated commit message, which stores the changes in the repository with the appropriate message.

[0668] In this way, the present invention automatically analyzes changes and generates commit messages, eliminating the need for users to manually create messages. Furthermore, automating the analysis and generation process helps maintain consistent commit messages and improves repository management efficiency.

[0669] The processing flow will be explained below.

[0670] Step 1:

[0671] The server retrieves the changes in the version control system's staging area by running the version control system command git diff --cached, which retrieves a textual version control diff between the previous commit and the current staged state.

[0672] Step 2:

[0673] The server analyzes the difference information it has obtained and extracts the names of the changed files. To do this, the server uses the regular expression re.findall(r'diff --git a\ / (.?) ', diff) to extract the changed file names in the difference text. This extracts a list of file paths following "diff --git a / " from the difference text.

[0674] Step 3:

[0675] The server uses the extracted filenames to generate a commit message. At this stage, the server concatenates the listed filenames into a comma-separated string and creates a commit message containing that string. This message has the format "Changed files: [filename1], [filename2], ...".

[0676] Step 4:

[0677] The server uses the generated commit message to perform the commit to the version control system. The server runs the command git commit -m "generated commit message", which commits the staged changes to the repository.

[0678] Step 5:

[0679] The server will notify the user of the message after the commit. The server will display the message "Committed with message: [generated commit message]", which will allow the user to confirm that the commit was successful.

[0680] As described above, through this series of processes, the server obtains the difference between the changes, automatically generates an appropriate commit message, and commits it. This saves the user the trouble of creating a commit message, and improves the efficiency of repository management.

[0681] Example 1

[0682] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0683] In software development, manually reviewing changes and creating commit messages in version control systems is time-consuming, prone to inconsistency, and prone to human error. Generating appropriate commit messages also requires knowledge and experience, placing a burden on many developers. Furthermore, there is a need for a method to efficiently analyze the differences between changes and automatically generate commit messages.

[0684] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0685] In this invention, the server includes: means for acquiring differences between staged changes; means for analyzing changed file names from the acquired differences using regular expressions; means for generating a commit message in the format "Changed files: [file name]" based on the analyzed file names; and means for committing to the version control system using the generated commit message. This enables automatic analysis of changes and automatic generation of consistent commit messages, reducing the burden on users and preventing human error.

[0686] "Staging" is the process in a version control system of temporarily storing modified files in preparation for the next commit.

[0687] A "diff" is information indicating the changes between the contents of the current working directory and the contents that were previously committed.

[0688] A "regular expression" is an encoding rule that specifies a string pattern and allows you to search, extract, and replace strings that match that pattern.

[0689] A "commit message" is text in a version control system that explains the changes that have been made, and is information that is recorded together when a change is committed to a repository.

[0690] A "version control system" is a system used in software development to manage the change history of program code and documents and to enable multiple developers to work together.

[0691] A "repository" is a database in a version control system that records and stores the change history of files and data groups.

[0692] A "generative AI model" is an algorithmic model of artificial intelligence that learns from large amounts of data and automatically generates appropriate outputs for specific tasks.

[0693] This invention relates to a system that uses a version control system in software development to automatically obtain differences between changes, automatically generate commit messages, and execute commits. This system automates a series of processes centered on the server, reducing the user's workload and enabling the generation of consistent commit messages.

[0694] The system uses the following hardware and software:

[0695] 1. Hardware:

[0696] Server (a computer with a processor, memory, and storage)

[0697] 2. Software:

[0698] Version control system (e.g. Git)

[0699] Regular expression libraries (e.g. Perl compatible regular expressions)

[0700] Generative AI Models

[0701] Specific processing

[0702] Get the diff:

[0703] The server uses the version control system's commands (e.g. "git diff --staged") to get a diff of the staged changes, allowing the server to see the differences between the current working directory and the most recent commit.

[0704] Filename parsing:

[0705] The server analyzes the changed file names based on the difference information it has obtained using regular expressions. Specifically, it uses regular expressions (e.g., "^\+\+\+ b / (.$)") to efficiently extract the changed file names from the difference information.

[0706] Generate a commit message:

[0707] The server uses the parsed filenames to generate appropriate commit messages, in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[0708] Perform the commit:

[0709] The server commits the changes to the version control system by running a command (e.g., "git commit -m 'Changed files: hello.py, README.md'") with the generated commit message, which stores the changes properly in the repository.

[0710] Specific examples

[0711] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, running the system with these changes staged will perform the following actions:

[0712] 1. Get the diff:

[0713] The server runs "git diff --staged" to obtain the difference information between the staged "hello.py" and "README.md".

[0714] 2. File name analysis:

[0715] The server analyzes the difference information using regular expressions and extracts "hello.py" and "README.md" as changed file names.

[0716] 3. Generate a commit message:

[0717] The server generates a commit message saying "Changed files: hello.py, README.md".

[0718] 4. Perform the commit:

[0719] The server executes the command "git commit -m 'Changed files: hello.py, README.md'" to commit the changes to the repository.

[0720] Prompt Sentence Examples

[0721] Below are some example prompts to input to a generative AI model:

[0722] A user creates a new file "hello.py" locally and updates the file "README.md". After staging this change, the server runs "git diff --staged" to obtain the difference information. The difference information is analyzed using regular expressions to extract "hello.py" and "README.md". Based on the extracted file names, a commit message "Changed files: hello.py, README.md" is generated, and this is committed to the repository by running the command "git commit -m 'Changed files: hello.py, README.md'".

[0723] Operating the system in this way allows for automated analysis of changes and generation of commit messages, reducing the burden on users and the risk of errors.

[0724] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0725] Processing flow

[0726] Step 1:

[0727] The server runs commands from your version control system (e.g. Git) to keep track of the changes you've made locally.

[0728] Specific behavior:

[0729] The server runs the "git diff --staged" command to get the diff information for the staged changes.

[0730] input:

[0731] Changes staged in a version control system.

[0732] Data processing and calculation:

[0733] Obtain difference information using the version control system command "git diff --staged".

[0734] output:

[0735] The diff information for the staged changes.

[0736] Step 2:

[0737] The server extracts the changed file name from the acquired difference information.

[0738] Specific behavior:

[0739] The server parses the diff information using a regular expression (e.g. "^\+\+\+ b / (.$)") and extracts the changed filenames.

[0740] input:

[0741] The difference information obtained in step 1.

[0742] Data processing and calculation:

[0743] Extract changed file names from difference information using text analysis with regular expressions.

[0744] output:

[0745] A list of the extracted modified filenames (e.g. "hello.py" "README.md").

[0746] Step 3:

[0747] The server generates an appropriate commit message based on the extracted filename.

[0748] Specific behavior:

[0749] The server uses the parsed filename to generate a commit message of the form "Changed files: [filename]".

[0750] input:

[0751] The renamed filename extracted in step 2.

[0752] Data processing and calculation:

[0753] A string formatter to generate a commit message based on the extracted filename.

[0754] output:

[0755] The generated commit message (e.g., "Changed files: hello.py, README.md").

[0756] Step 4:

[0757] The server executes a commit to the version control system using the generated commit message.

[0758] Specific behavior:

[0759] The server runs the command "git commit -m 'Changed files: hello.py, README.md'" to save the changes to the repository.

[0760] input:

[0761] The commit message generated in step 3.

[0762] Data processing and calculation:

[0763] Executes a commit command to the version control system.

[0764] output:

[0765] The changes have been committed to the repository.

[0766] These steps allow the server to automatically analyze the changes, generate appropriate commit messages, and commit them to the version control system, saving users the trouble of manually reviewing the changes and creating commit messages.

[0767] (Application example 1)

[0768] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0769] Currently, software updates for factory robots are often managed manually, resulting in time-consuming and labor-intensive update tasks and a high risk of human error. Furthermore, updates are often recorded inconsistently, making maintenance and troubleshooting difficult. The present invention addresses these issues by providing a system for automatic software update management.

[0770] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0771] In this invention, the server includes means for acquiring differences in the changes, means for analyzing the changed file names, means for generating a commit message based on the analyzed file names, means for committing to the version control system using the generated commit message, and means for saving the generated commit message in a repository as changes to the software installed in the control unit of the factory robot. This automates software update management for the factory robot, enabling consistent update records and efficient maintenance.

[0772] The "diff of changes" is the difference between the changes staged in the version control system and the changes that were previously committed.

[0773] "File name analysis" is the process of identifying the names of files that have been changed from the acquired differences.

[0774] A "commit message" is a brief message in a version control system that explains the changes.

[0775] A "version control system" is a system that manages the change history of software source code and documents.

[0776] A "factory robot" is a mechanical device used to automate tasks in the manufacturing industry.

[0777] "Control Unit" means a hardware or software component that operates and controls a factory robot.

[0778] A "repository" is a place within a version control system that stores the version history of files.

[0779] This invention is a system that automates software update management for factory robots, obtaining the differences in changes, automatically generating commit messages, and appropriately recording and applying the changes to the control units of the factory robots.

[0780] The server first uses a version control system (e.g., Git) to obtain a diff of the staged changes, which gives the difference between the current working directory and the most recent commit. The server then uses regular expressions to parse the resulting diff for changed filenames. This parsing process results in a list of all changed filenames.

[0781] Next, the server automatically generates an appropriate commit message based on the filename obtained through the analysis. This message uses the format "Changed files: [filename]" so that anyone can understand the changes at a glance. The server then uses the generated commit message to execute a commit to the version control system, and the changes are saved in the repository.

[0782] Furthermore, the server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot. Based on the information stored in this repository, the software of the factory robot is automatically updated.

[0783] For example, if a user creates a new "robot_control.py" file and updates an existing "config.yaml" file in a factory control unit, running the system with these changes staged in a version control system will result in the following behavior:

[0784] 1. The server executes a specific command in the version control system to retrieve the staged changes and obtain the difference information.

[0785] 2. Next, the server analyzes the acquired difference information using regular expressions and extracts the changed file names "robot_control.py" and "config.yaml".

[0786] 3. The server generates a commit message based on the extracted file names: "Changed files: robot_control.py, config.yaml".

[0787] 4. Using this commit message, the server commits the changes to the version control system.

[0788] 5. Finally, the server stores the generated commit message in the repository as a change to the software installed in the control unit of the factory robot.

[0789] In this way, the system according to the present invention makes software update management in factory automation processes more efficient, consistent, and reliable.

[0790] Example of an input prompt for a generative AI model:

[0791] "Design a system to automatically version control changes to software installed on the control units of factory robots. The system will include functionality to obtain diffs, parse filenames, generate commit messages, and execute commits. Please also provide a Python script for each function."

[0792] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0793] Step 1:

[0794] The server executes version control system commands to obtain the diff of the staged changes.

[0795] Specifically, it executes the Git command "git diff --staged" and obtains its output in text format. The input is the Git command with the "--staged" option, and the output is text of the difference information for the staged files.

[0796] Step 2:

[0797] The server analyzes the acquired difference information and lists the changed file names.

[0798] Specifically, it extracts file names from the difference information using regular expressions. The input is the text of the difference information obtained in step 1, and the output is a list of changed file names.

[0799] Step 3:

[0800] The server will automatically generate a commit message based on the name of the file that was changed.

[0801] Specifically, it creates a message in the format "Changed files: [filename]", where the input is the list of filenames obtained in step 2, and the output is the text of the generated commit message.

[0802] Step 4:

[0803] The server commits the changes to the version control system using the generated commit message.

[0804] Specifically, it runs the Git command "git commit -m [commit message]", where the input is the commit message text generated in step 3, and the output is a success or failure message.

[0805] Step 5:

[0806] The server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot.

[0807] Specifically, the robot control software repository is updated. The input is the text of the commit message generated in step 3, and the output is a message resulting from the update to the repository.

[0808] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0809] The present invention relates to a system that acquires differences between changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing user emotions when using a version control system in software development. The system includes a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, a means for committing, and an emotion engine that recognizes user emotions.

[0810] Get diff

[0811] The server uses version control system commands to diff the staged changes, so that the server knows the differences between the current working directory and the most recent commit.

[0812] Filename Parsing

[0813] The server analyzes the changed file names based on the difference information it has obtained, using regular expressions to efficiently and accurately list the changed file names.

[0814] Generate a commit message

[0815] The server generates a commit message based on the parsed filenames, in the format "Changed files: [filename1], [filename2], ...".

[0816] Emotional engine regulation

[0817] The server recognizes the user's emotions using an emotion engine. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to identify the user's emotional state. The server adjusts the commit message based on this emotional information.

[0818] For example, if a user is in a stressful state, the server can soften the tone of the commit message and add an encouraging message, such as "Changed files: hello.py, README.md. Take a break, you're doing great!" Conversely, if a user is in a positive emotional state, it can add positive comments to the commit message.

[0819] Performing a commit

[0820] The server uses the generated commit message to perform a commit to the version control system, which stores the changes in the repository.

[0821] Specific examples

[0822] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0823] 1. Get diff: The server runs the git diff --cached command to get the diff of the staged changes.

[0824] 2. File name analysis: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[0825] 3. Generate a message: The server generates a message in the format "Changed files: hello.py, README.md".

[0826] 4. Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[0827] 5. Perform the commit: The server performs the commit to the version control system using the generated commit message.

[0828] 6. Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0829] In this way, the present invention automatically analyzes changes, automatically generates appropriate commit messages, and adjusts messages according to the user's feelings, thereby improving user work efficiency and the quality of repository management.

[0830] The processing flow will be explained below.

[0831] Step 1:

[0832] The server retrieves the changes from the staging area of ​​the version control system by running the git diff --cached command and receiving the diff information in text format on standard output, including the names of the changed files and details of the changes.

[0833] Step 2:

[0834] The server analyzes the difference information and extracts the changed file names. The server uses a regular expression to identify the file path following "diff --git a / " in the difference text. This extracts the changed file names in a list format.

[0835] Step 3:

[0836] The server generates the initial commit message based on the extracted filenames. The server concatenates the listed filenames into a comma-separated string to form a commit message of the form "Changed files: [filename1], [filename2], ...".

[0837] Step 4:

[0838] The server uses an emotion engine to recognize the user's emotions. The emotion engine analyzes the user's input and biometric information (e.g., voice tone and facial expression data) to identify the emotional state the user is experiencing. For example, it determines whether the user is feeling stressed through voice input or facial recognition.

[0839] Step 5:

[0840] The server adjusts the initial commit message based on the user's perceived emotions. For example, if the server determines that the user is stressed, it adds encouraging words like "Keep up the great work!" to the message. Conversely, if the user is experiencing positive emotions, it adds positive comments like "Excellent progress!".

[0841] Step 6:

[0842] The server uses the generated commit message to execute a commit to the version control system, specifically by running the git commit -m "generated commit message" command, which commits the staged changes to the repository.

[0843] Step 7:

[0844] The server notifies the user that the commit is complete. The server displays the message "Committed with message: [generated commit message]" on the terminal, allowing the user to confirm that the commit was successful.

[0845] By following these steps, users can automatically obtain the difference between changes and efficiently commit using appropriately adjusted commit messages. This series of processes saves users the trouble of creating commit messages and improves work efficiency.

[0846] Example 2

[0847] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0848] Version control systems in modern software development are required to efficiently manage changes and generate appropriate commit messages. However, manually creating commit messages can be error-prone and can be stressful due to the user's emotional state. This can lead to problems such as reduced work efficiency and a decline in the quality of repository management. There is a need to solve this issue and provide a system that generates highly accurate commit messages and takes user emotions into consideration.

[0849] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0850] In this invention, the server includes a means for acquiring the difference of the changes, a means for analyzing the changed file names from the acquired difference, a means for generating a commit message based on the analyzed file names, a means for recognizing the emotional state of the user and adjusting the commit message, and a means for committing to the version control system using the generated commit message. This makes it possible to efficiently manage the changes and generate an appropriate commit message according to the emotional state of the user.

[0851] The "diff of changes" is information that indicates the difference between the current working directory and the contents that were previously committed.

[0852] "File name analysis" is the process of identifying changed file names from the difference information.

[0853] A "commit message" is a message that clearly describes the changes and is used when committing them to a version control system.

[0854] The "user's emotional state" is information that indicates the user's current emotional state, and is a state that is recognized by analyzing input and biometric information.

[0855] The "changed file name" is the name of the file that was changed in the version control system.

[0856] An "emotion engine" is a system that analyzes and recognizes a user's emotional state based on their input and biometric information.

[0857] A "version control system" is a system for managing versions of software source code, documents, etc., and tracking change history and branches.

[0858] "Commit" is the operation of registering changes in a repository and saving them in a version control system.

[0859] "Staging" is the process of preparing changes for subsequent commit.

[0860] The present invention relates to a system that, when using a version control system in software development, acquires differences in changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing the user's emotions. The system includes means for acquiring differences in changes, means for analyzing changed file names from the acquired differences, means for generating a commit message based on the analyzed file names, means for adjusting the commit message by recognizing the user's emotional state, and means for committing to the version control system using the generated commit message.

[0861] Get diff

[0862] The server uses commands from the version control system to obtain the differences between the staged changes. Specifically, the server runs the git diff --cached command to determine the differences between the current working directory and the most recently committed content. By obtaining this difference information, the server can accurately identify the file names and changes required for the next process.

[0863] Filename Parsing

[0864] The server analyzes the changed file names based on the difference information it has obtained. Regular expressions are used for this analysis. By using regular expressions, it is possible to efficiently and accurately list the changed file names from the difference information. The listed file names are used to generate the next commit message.

[0865] Generate a commit message

[0866] The server generates a commit message based on the parsed filenames. The generated message is in the format "Changed files: [filename1], [filename2], ...". This makes it easy to see at a glance who changed which files.

[0867] Emotional engine regulation

[0868] The server uses an emotion engine to recognize the user's emotional state. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to determine the user's emotion. The server adjusts the commit message based on this emotional information. For example, if the user is in a stressful state, the server can add an encouraging comment to the commit message. As a specific example, it can generate an adjusted message such as "Changed files: hello.py, README.md. Keep up the great work!"

[0869] Performing a commit

[0870] The server uses the generated commit message to execute a commit to the version control system, which saves the changes to the repository. The server executes the commit using the git commit -m "generated commit message" command.

[0871] Specific examples

[0872] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0873] Diff: The server runs the git diff --cached command to get the diff of the staged changes.

[0874] Filename parsing: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[0875] Generate a commit message: The server generates a message in the format "Changed files: hello.py, README.md".

[0876] Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[0877] Perform the commit: The server performs the commit to the version control system using the generated commit message.

[0878] Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0879] This system automatically generates appropriate commit messages, improving user work efficiency while enabling messages to be adjusted according to emotional fluctuations.

[0880] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0881] Step 1: Get the diff

[0882] The server uses commands from the version control system to get the diff of the staged changes. Specifically, the server runs the git diff --cached command to get the difference between the current working directory and the most recently committed content. The diff information is the input, and the output is the diff data as a comparison result.

[0883] Specific behavior:

[0884] The server runs the git diff --cached command to get the diffs of the changed files, which are temporarily stored in memory.

[0885] Step 2: Parsing the filename

[0886] Analyzes the changed file names based on the difference information obtained from the server. The input is the difference information and the output is a list of changed file names. Regular expressions are used for this analysis.

[0887] Specific behavior:

[0888] The server analyzes the diff information and applies regular expressions to extract the changed filenames, which are organized into a list and stored in memory.

[0889] Step 3: Generate a commit message

[0890] The server generates a commit message based on the parsed filenames. The input is a list of changed filenames, and the output is the commit message. The generated message is in the format "Changed files: [filename1], [filename2], ...".

[0891] Specific behavior:

[0892] The server reads the list of filenames and uses them to construct a commit message in the specified format, which is then stored in memory.

[0893] Step 4: Emotional Engine Adjustment

[0894] The server uses an emotion engine to recognize the user's emotional state. The input is the user's input and biometric information, and the output is a commit message that reflects the user's emotional state. The emotion engine performs analysis and identifies the user's emotion.

[0895] Specific behavior:

[0896] 1. The server launches the emotion engine and collects user input (e.g., keyboard typing speed, mouse movements) and biometric information (e.g., tone of voice, facial expression data).

[0897] 2. The emotion engine analyzes the collected data and determines the user's emotional state.

[0898] 3. The server adjusts the commit message based on this emotional information, for example adding an encouraging message like "Keep up the great work!" if the user is stressed.

[0899] Step 5: Performing a Commit

[0900] The server uses the generated commit message to execute a commit into the version control system. The input is the commit message, and the output is the changes reflected in the repository.

[0901] Specific behavior:

[0902] The server executes the git commit -m "generated commit message" command, saving the changes to the repository. Verify that the commit was successful.

[0903] Step 6: Message Notification

[0904] The server notifies the user with a successful commit message. The input is the status that the commit was successful, and the output is a notification message to the user.

[0905] Specific behavior:

[0906] 1. The server generates a commit success message and sends a notification to the user's device.

[0907] 2. The user will see the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[0908] (Application example 2)

[0909] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0910] In software development, when properly obtaining the difference between changes and generating commit messages, the process is mechanically performed without considering the user's feelings, which can lead to a problem of reduced work efficiency depending on the user's psychological state. In particular, there is a problem that processing monotonous commit messages under stress reduces motivation, resulting in a decline in work efficiency.

[0911] The specification process by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring differences in changes, means for analyzing the changed data from the acquired differences, means for generating a commit message based on the analyzed data, means for adjusting the commit message using an emotion engine that recognizes the user's emotions, and means for committing to the data management system using the generated commit message. This makes it possible to automatically analyze changes and automatically generate appropriate commit messages, as well as adjust the message according to the user's emotions, thereby improving user work efficiency and the quality of repository management.

[0912] The "means for obtaining the difference of the changes" is a means for detecting and recording the changes newly made in the software repository.

[0913] The "means for analyzing changed data" is a means for automatically analyzing and identifying affected files and data based on the acquired difference information.

[0914] The "means for generating a commit message" is a means for automatically creating a commit message in a format that is easy for a user to understand, based on the analyzed data.

[0915] An "emotion engine" is software or hardware that analyzes a user's facial expressions, voice, input data, etc., and identifies the user's emotional state.

[0916] The "means for adjusting a commit message" refers to a means for appropriately changing the tone and content of the generated commit message depending on the emotional state of the user identified by the emotion engine.

[0917] A "data management system" is a system that primarily manages the versioning of software repositories, and its purpose is to store, manage, and share change histories.

[0918] This invention is a system for supporting software update management for factory robots, in which a server obtains the differences in changes, analyzes the changed data, generates a commit message, recognizes the user's emotions, adjusts the commit message, and commits it.

[0919] The server uses the following hardware and software: The hardware includes a basic server environment, a smartphone, a head-mounted display, a microphone, a camera, etc. The software uses PyGit2 for operating Git repositories, Google Speech Recognition API for voice recognition, EmotionRecognizer for emotion recognition, and gTTS for text-to-speech synthesis.

[0920] The server first retrieves the diffs of the factory robot's software changes from the Git repository, allowing the server to understand what new changes have been made. The diff information is then parsed using regular expressions to automatically identify which files have changed.

[0921] The server then generates a commit message based on the retrieved diff information, which has the format "Modified files: [filename1], [filename2], ..." But the key here is that the server is aware of the user's emotional state and adjusts the message accordingly.

[0922] To recognize the user's emotional state, voice input and facial expression data are used. When the user inputs commands into the microphone, the server converts the voice commands into text data using the Google Speech Recognition API. Furthermore, it uses EmotionRecognizer to analyze the user's emotions and adjusts the content of the commit message depending on whether the user is in a stressful or positive state. For example, if the user is in a stressful state, a message such as "Good luck, good job!" is added.

[0923] Finally, the server executes the commit to the Git repository using the generated commit message. After the commit process is successful, the result is notified by voice. The server uses gTTS to synthesize the commit result and notify the user.

[0924] As a concrete example, consider the case where a user modifies "controller.py" and "sensor_data.py" while updating a robot's software. If the user speaks into the microphone and says "Please commit," the system recognizes the voice and determines that the user is stressed. In this case, it generates an encouraging message such as "Modified files: controller.py, sensor_data.py. Keep up the great work!" and executes the commit.

[0925] An example of a prompt is "Get the diff to commit and analyze the changed file names. Analyze the user's sentiment from the voice input and adjust the commit message." For example, it is executed by the voice input "Please commit."

[0926] In this way, the present invention realizes automatic analysis of changes in software management of factory robots, generation of appropriate commit messages, and adjustment of messages according to user emotions, thereby improving work efficiency and management quality.

[0927] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0928] Step 1:

[0929] The server retrieves the diff of changes from the Git repository, specifically by running the git diff --cached command to retrieve the staged changes. The input is the Git repository with the staged changes, and the output is the diff information.

[0930] Step 2:

[0931] The server analyzes the changed data based on the difference information it has acquired. It analyzes the difference information using regular expressions and extracts the changed file names. The input is the difference information, and the output is a list of changed file names.

[0932] Step 3:

[0933] The server generates a commit message based on the parsed file names. For example, if the changed file names are "controller.py" and "sensor_data.py", it generates a message of the form "Changed files: controller.py, sensor_data.py". The input is a list of changed file names, and the output is a basic commit message.

[0934] Step 4:

[0935] The user inputs voice instructions into the microphone to adjust the commit message, and the server converts the speech to text data using the Google Speech Recognition API. The input is the user's voice instructions, and the output is text data.

[0936] Step 5:

[0937] The server identifies the user's emotional state based on the text data of the voice instructions. It uses EmotionRecognizer to analyze the text data and determine whether the user is in a stressful or positive state. The input is the text data of the voice instructions, and the output is the user's emotional state.

[0938] Step 6:

[0939] The server adjusts the commit message according to the perceived emotional state, for example, if the user is stressed, it adds an encouraging message such as "Keep up the good work, good job!" The input is a basic commit message and the user's emotional state, and the output is the adjusted commit message.

[0940] Step 7:

[0941] The server executes the commit to the Git repository using the adjusted commit message. It executes the git commit command using the generated commit message. The input is the adjusted commit message, and the output is a notification of the success of the commit operation.

[0942] Step 8:

[0943] The server notifies the user of the result of the commit process. It uses gTTS to synthesize the commit result and notifies the user by voice. The input is a notification of the success of the commit process, and the output is a voice notification of the commit result.

[0944] In this way, the server automatically analyzes changes in software management of factory robots, automatically generates commit messages, adjusts messages according to the user's emotions, and provides audio notification of the commit contents.

[0945] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0946] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0947] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[0948] [Fourth embodiment]

[0949] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[0950] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[0951] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0952] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[0953] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0954] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0955] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0956] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[0957] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0958] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0959] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0960] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0961] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[0962] This invention relates to a system for acquiring differences in changes, automatically generating commit messages, and performing commits in a version control system for software development. The system is composed of a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, and a means for performing commits.

[0963] Get diff

[0964] The server uses commands from the version control system to diff the staged changes, so that the server knows the difference between the current working directory and the most recent commit.

[0965] Filename Parsing

[0966] The server analyzes the changed file names based on the difference information it has acquired. This analysis uses a technique to extract specific patterns using regular expressions. Using regular expressions makes it possible to list the changed file names efficiently and accurately.

[0967] Generate a commit message

[0968] The server uses the parsed filenames to automatically generate appropriate commit messages, for example in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[0969] Performing a commit

[0970] The server executes the command containing the generated commit message to commit to the version control system, which stores the changes in the repository.

[0971] Specific examples

[0972] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[0973] 1. Get diff: The server executes a specific command in the version control system to retrieve the staged changes and obtain the diff information.

[0974] 2. File analysis: The server analyzes the obtained difference information using regular expressions and extracts the changed file names "hello.py" and "README.md".

[0975] 3. Generate message: The server generates a commit message based on the extracted file names: "Changed files: hello.py, README.md".

[0976] 4. Perform the commit: Finally, the server commits the changes to the version control system using the generated commit message, which stores the changes in the repository with the appropriate message.

[0977] In this way, the present invention automatically analyzes changes and generates commit messages, eliminating the need for users to manually create messages. Furthermore, automating the analysis and generation process helps maintain consistent commit messages and improves repository management efficiency.

[0978] The processing flow will be explained below.

[0979] Step 1:

[0980] The server retrieves the changes in the version control system's staging area by running the version control system command git diff --cached, which retrieves a textual version control diff between the previous commit and the current staged state.

[0981] Step 2:

[0982] The server analyzes the difference information it has obtained and extracts the names of the changed files. To do this, the server uses the regular expression re.findall(r'diff --git a\ / (.?) ', diff) to extract the changed file names in the difference text. This extracts a list of file paths following "diff --git a / " from the difference text.

[0983] Step 3:

[0984] The server uses the extracted filenames to generate a commit message. At this stage, the server concatenates the listed filenames into a comma-separated string and creates a commit message containing that string. This message has the format "Changed files: [filename1], [filename2], ...".

[0985] Step 4:

[0986] The server uses the generated commit message to perform the commit to the version control system. The server runs the command git commit -m "generated commit message", which commits the staged changes to the repository.

[0987] Step 5:

[0988] The server will notify the user of the message after the commit. The server will display the message "Committed with message: [generated commit message]", which will allow the user to confirm that the commit was successful.

[0989] As described above, through this series of processes, the server obtains the difference between the changes, automatically generates an appropriate commit message, and commits it. This saves the user the trouble of creating a commit message, and improves the efficiency of repository management.

[0990] Example 1

[0991] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[0992] In software development, manually reviewing changes and creating commit messages in version control systems is time-consuming, prone to inconsistency, and prone to human error. Generating appropriate commit messages also requires knowledge and experience, placing a burden on many developers. Furthermore, there is a need for a method to efficiently analyze the differences between changes and automatically generate commit messages.

[0993] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0994] In this invention, the server includes: means for acquiring differences between staged changes; means for analyzing changed file names from the acquired differences using regular expressions; means for generating a commit message in the format "Changed files: [file name]" based on the analyzed file names; and means for committing to the version control system using the generated commit message. This enables automatic analysis of changes and automatic generation of consistent commit messages, reducing the burden on users and preventing human error.

[0995] "Staging" is the process in a version control system of temporarily storing modified files in preparation for the next commit.

[0996] A "diff" is information indicating the changes between the contents of the current working directory and the contents that were previously committed.

[0997] A "regular expression" is an encoding rule that specifies a string pattern and allows you to search, extract, and replace strings that match that pattern.

[0998] A "commit message" is text in a version control system that explains the changes that have been made, and is information that is recorded together when a change is committed to a repository.

[0999] A "version control system" is a system used in software development to manage the change history of program code and documents and to enable multiple developers to work together.

[1000] A "repository" is a database in a version control system that records and stores the change history of files and data groups.

[1001] A "generative AI model" is an algorithmic model of artificial intelligence that learns from large amounts of data and automatically generates appropriate outputs for specific tasks.

[1002] This invention relates to a system that uses a version control system in software development to automatically obtain differences between changes, automatically generate commit messages, and execute commits. This system automates a series of processes centered on the server, reducing the user's workload and enabling the generation of consistent commit messages.

[1003] The system uses the following hardware and software:

[1004] 1. Hardware:

[1005] Server (a computer with a processor, memory, and storage)

[1006] 2. Software:

[1007] Version control system (e.g. Git)

[1008] Regular expression libraries (e.g. Perl compatible regular expressions)

[1009] Generative AI Models

[1010] Specific processing

[1011] Get the diff:

[1012] The server uses the version control system's commands (e.g. "git diff --staged") to get a diff of the staged changes, allowing the server to see the differences between the current working directory and the most recent commit.

[1013] Filename parsing:

[1014] The server analyzes the changed file names based on the difference information it has obtained using regular expressions. Specifically, it uses regular expressions (e.g., "^\+\+\+ b / (.$)") to efficiently extract the changed file names from the difference information.

[1015] Generate a commit message:

[1016] The server uses the parsed filenames to generate appropriate commit messages, in the format "Changed files: [filename]", which allows users to understand at a glance what has changed.

[1017] Perform the commit:

[1018] The server commits the changes to the version control system by running a command (e.g., "git commit -m 'Changed files: hello.py, README.md'") with the generated commit message, which stores the changes properly in the repository.

[1019] Specific examples

[1020] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, running the system with these changes staged will perform the following actions:

[1021] 1. Get the diff:

[1022] The server runs "git diff --staged" to obtain the difference information between the staged "hello.py" and "README.md".

[1023] 2. File name analysis:

[1024] The server analyzes the difference information using regular expressions and extracts "hello.py" and "README.md" as changed file names.

[1025] 3. Generate a commit message:

[1026] The server generates a commit message saying "Changed files: hello.py, README.md".

[1027] 4. Perform the commit:

[1028] The server executes the command "git commit -m 'Changed files: hello.py, README.md'" to commit the changes to the repository.

[1029] Prompt Sentence Examples

[1030] Below are some example prompts to input to a generative AI model:

[1031] A user creates a new file "hello.py" locally and updates the file "README.md". After staging this change, the server runs "git diff --staged" to obtain the difference information. The difference information is analyzed using regular expressions to extract "hello.py" and "README.md". Based on the extracted file names, a commit message "Changed files: hello.py, README.md" is generated, and this is committed to the repository by running the command "git commit -m 'Changed files: hello.py, README.md'".

[1032] Operating the system in this way allows for automated analysis of changes and generation of commit messages, reducing the burden on users and the risk of errors.

[1033] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1034] Processing flow

[1035] Step 1:

[1036] The server runs commands from your version control system (e.g. Git) to keep track of the changes you've made locally.

[1037] Specific behavior:

[1038] The server runs the "git diff --staged" command to get the diff information for the staged changes.

[1039] input:

[1040] Changes staged in a version control system.

[1041] Data processing and calculation:

[1042] Obtain difference information using the version control system command "git diff --staged".

[1043] output:

[1044] The diff information for the staged changes.

[1045] Step 2:

[1046] The server extracts the changed file name from the acquired difference information.

[1047] Specific behavior:

[1048] The server parses the diff information using a regular expression (e.g. "^\+\+\+ b / (.$)") and extracts the changed filenames.

[1049] input:

[1050] The difference information obtained in step 1.

[1051] Data processing and calculation:

[1052] Extract changed file names from difference information using text analysis with regular expressions.

[1053] output:

[1054] A list of the extracted modified filenames (e.g. "hello.py" "README.md").

[1055] Step 3:

[1056] The server generates an appropriate commit message based on the extracted filename.

[1057] Specific behavior:

[1058] The server uses the parsed filename to generate a commit message of the form "Changed files: [filename]".

[1059] input:

[1060] The renamed filename extracted in step 2.

[1061] Data processing and calculation:

[1062] A string formatter to generate a commit message based on the extracted filename.

[1063] output:

[1064] The generated commit message (e.g., "Changed files: hello.py, README.md").

[1065] Step 4:

[1066] The server executes a commit to the version control system using the generated commit message.

[1067] Specific behavior:

[1068] The server runs the command "git commit -m 'Changed files: hello.py, README.md'" to save the changes to the repository.

[1069] input:

[1070] The commit message generated in step 3.

[1071] Data processing and calculation:

[1072] Executes a commit command to the version control system.

[1073] output:

[1074] The changes have been committed to the repository.

[1075] These steps allow the server to automatically analyze the changes, generate appropriate commit messages, and commit them to the version control system, saving users the trouble of manually reviewing the changes and creating commit messages.

[1076] (Application example 1)

[1077] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1078] Currently, software updates for factory robots are often managed manually, resulting in time-consuming and labor-intensive update tasks and a high risk of human error. Furthermore, updates are often recorded inconsistently, making maintenance and troubleshooting difficult. The present invention addresses these issues by providing a system for automatic software update management.

[1079] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1080] In this invention, the server includes means for acquiring differences in the changes, means for analyzing the changed file names, means for generating a commit message based on the analyzed file names, means for committing to the version control system using the generated commit message, and means for saving the generated commit message in a repository as changes to the software installed in the control unit of the factory robot. This automates software update management for the factory robot, enabling consistent update records and efficient maintenance.

[1081] The "diff of changes" is the difference between the changes staged in the version control system and the changes that were previously committed.

[1082] "File name analysis" is the process of identifying the names of files that have been changed from the acquired differences.

[1083] A "commit message" is a brief message in a version control system that explains the changes.

[1084] A "version control system" is a system that manages the change history of software source code and documents.

[1085] A "factory robot" is a mechanical device used to automate tasks in the manufacturing industry.

[1086] "Control Unit" means a hardware or software component that operates and controls a factory robot.

[1087] A "repository" is a place within a version control system that stores the version history of files.

[1088] This invention is a system that automates software update management for factory robots, obtaining the differences in changes, automatically generating commit messages, and appropriately recording and applying the changes to the control units of the factory robots.

[1089] The server first uses a version control system (e.g., Git) to obtain a diff of the staged changes, which gives the difference between the current working directory and the most recent commit. The server then uses regular expressions to parse the resulting diff for changed filenames. This parsing process results in a list of all changed filenames.

[1090] Next, the server automatically generates an appropriate commit message based on the filename obtained through the analysis. This message uses the format "Changed files: [filename]" so that anyone can understand the changes at a glance. The server then uses the generated commit message to execute a commit to the version control system, and the changes are saved in the repository.

[1091] Furthermore, the server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot. Based on the information stored in this repository, the software of the factory robot is automatically updated.

[1092] For example, if a user creates a new "robot_control.py" file and updates an existing "config.yaml" file in a factory control unit, running the system with these changes staged in a version control system will result in the following behavior:

[1093] 1. The server executes a specific command in the version control system to retrieve the staged changes and obtain the difference information.

[1094] 2. Next, the server analyzes the acquired difference information using regular expressions and extracts the changed file names "robot_control.py" and "config.yaml".

[1095] 3. The server generates a commit message based on the extracted file names: "Changed files: robot_control.py, config.yaml".

[1096] 4. Using this commit message, the server commits the changes to the version control system.

[1097] 5. Finally, the server stores the generated commit message in the repository as a change to the software installed in the control unit of the factory robot.

[1098] In this way, the system according to the present invention makes software update management in factory automation processes more efficient, consistent, and reliable.

[1099] Example of an input prompt for a generative AI model:

[1100] "Design a system to automatically version control changes to software installed on the control units of factory robots. The system will include functionality to obtain diffs, parse filenames, generate commit messages, and execute commits. Please also provide a Python script for each function."

[1101] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1102] Step 1:

[1103] The server executes version control system commands to obtain the diff of the staged changes.

[1104] Specifically, it executes the Git command "git diff --staged" and obtains its output in text format. The input is the Git command with the "--staged" option, and the output is text of the difference information for the staged files.

[1105] Step 2:

[1106] The server analyzes the acquired difference information and lists the changed file names.

[1107] Specifically, it extracts file names from the difference information using regular expressions. The input is the text of the difference information obtained in step 1, and the output is a list of changed file names.

[1108] Step 3:

[1109] The server will automatically generate a commit message based on the name of the file that was changed.

[1110] Specifically, it creates a message in the format "Changed files: [filename]", where the input is the list of filenames obtained in step 2, and the output is the text of the generated commit message.

[1111] Step 4:

[1112] The server commits the changes to the version control system using the generated commit message.

[1113] Specifically, it runs the Git command "git commit -m [commit message]", where the input is the commit message text generated in step 3, and the output is a success or failure message.

[1114] Step 5:

[1115] The server stores the generated commit message in a repository as a change to the software installed in the control unit of the factory robot.

[1116] Specifically, the robot control software repository is updated. The input is the text of the commit message generated in step 3, and the output is a message resulting from the update to the repository.

[1117] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1118] The present invention relates to a system that acquires differences between changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing user emotions when using a version control system in software development. The system includes a means for acquiring differences, a means for analyzing changed file names, a means for generating commit messages, a means for committing, and an emotion engine that recognizes user emotions.

[1119] Get diff

[1120] The server uses version control system commands to diff the staged changes, so that the server knows the differences between the current working directory and the most recent commit.

[1121] Filename Parsing

[1122] The server analyzes the changed file names based on the difference information it has obtained, using regular expressions to efficiently and accurately list the changed file names.

[1123] Generate a commit message

[1124] The server generates a commit message based on the parsed filenames, in the format "Changed files: [filename1], [filename2], ...".

[1125] Emotional engine regulation

[1126] The server recognizes the user's emotions using an emotion engine. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to identify the user's emotional state. The server adjusts the commit message based on this emotional information.

[1127] For example, if a user is in a stressful state, the server can soften the tone of the commit message and add an encouraging message, such as "Changed files: hello.py, README.md. Take a break, you're doing great!" Conversely, if a user is in a positive emotional state, it can add positive comments to the commit message.

[1128] Performing a commit

[1129] The server uses the generated commit message to perform a commit to the version control system, which stores the changes in the repository.

[1130] Specific examples

[1131] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[1132] 1. Get diff: The server runs the git diff --cached command to get the diff of the staged changes.

[1133] 2. File name analysis: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[1134] 3. Generate a message: The server generates a message in the format "Changed files: hello.py, README.md".

[1135] 4. Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[1136] 5. Perform the commit: The server performs the commit to the version control system using the generated commit message.

[1137] 6. Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[1138] In this way, the present invention automatically analyzes changes, automatically generates appropriate commit messages, and adjusts messages according to the user's feelings, thereby improving user work efficiency and the quality of repository management.

[1139] The processing flow will be explained below.

[1140] Step 1:

[1141] The server retrieves the changes from the staging area of ​​the version control system by running the git diff --cached command and receiving the diff information in text format on standard output, including the names of the changed files and details of the changes.

[1142] Step 2:

[1143] The server analyzes the difference information and extracts the changed file names. The server uses a regular expression to identify the file path following "diff --git a / " in the difference text. This extracts the changed file names in a list format.

[1144] Step 3:

[1145] The server generates the initial commit message based on the extracted filenames. The server concatenates the listed filenames into a comma-separated string to form a commit message of the form "Changed files: [filename1], [filename2], ...".

[1146] Step 4:

[1147] The server uses an emotion engine to recognize the user's emotions. The emotion engine analyzes the user's input and biometric information (e.g., voice tone and facial expression data) to identify the emotional state the user is experiencing. For example, it determines whether the user is feeling stressed through voice input or facial recognition.

[1148] Step 5:

[1149] The server adjusts the initial commit message based on the user's perceived emotions. For example, if the server determines that the user is stressed, it adds encouraging words like "Keep up the great work!" to the message. Conversely, if the user is experiencing positive emotions, it adds positive comments like "Excellent progress!".

[1150] Step 6:

[1151] The server uses the generated commit message to execute a commit to the version control system, specifically by running the git commit -m "generated commit message" command, which commits the staged changes to the repository.

[1152] Step 7:

[1153] The server notifies the user that the commit is complete. The server displays the message "Committed with message: [generated commit message]" on the terminal, allowing the user to confirm that the commit was successful.

[1154] By following these steps, users can automatically obtain the difference between changes and efficiently commit using appropriately adjusted commit messages. This series of processes saves users the trouble of creating commit messages and improves work efficiency.

[1155] Example 2

[1156] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1157] Version control systems in modern software development are required to efficiently manage changes and generate appropriate commit messages. However, manually creating commit messages can be error-prone and can be stressful due to the user's emotional state. This can lead to problems such as reduced work efficiency and a decline in the quality of repository management. There is a need to solve this issue and provide a system that generates highly accurate commit messages and takes user emotions into consideration.

[1158] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1159] In this invention, the server includes a means for acquiring the difference of the changes, a means for analyzing the changed file names from the acquired difference, a means for generating a commit message based on the analyzed file names, a means for recognizing the emotional state of the user and adjusting the commit message, and a means for committing to the version control system using the generated commit message. This makes it possible to efficiently manage the changes and generate an appropriate commit message according to the emotional state of the user.

[1160] The "diff of changes" is information that indicates the difference between the current working directory and the contents that were previously committed.

[1161] "File name analysis" is the process of identifying changed file names from the difference information.

[1162] A "commit message" is a message that clearly describes the changes and is used when committing them to a version control system.

[1163] The "user's emotional state" is information that indicates the user's current emotional state, and is a state that is recognized by analyzing input and biometric information.

[1164] The "changed file name" is the name of the file that was changed in the version control system.

[1165] An "emotion engine" is a system that analyzes and recognizes a user's emotional state based on their input and biometric information.

[1166] A "version control system" is a system for managing versions of software source code, documents, etc., and tracking change history and branches.

[1167] "Commit" is the operation of registering changes in a repository and saving them in a version control system.

[1168] "Staging" is the process of preparing changes for subsequent commit.

[1169] The present invention relates to a system that, when using a version control system in software development, acquires differences in changes, automatically generates appropriate commit messages, and adjusts the commit messages by recognizing the user's emotions. The system includes means for acquiring differences in changes, means for analyzing changed file names from the acquired differences, means for generating a commit message based on the analyzed file names, means for adjusting the commit message by recognizing the user's emotional state, and means for committing to the version control system using the generated commit message.

[1170] Get diff

[1171] The server uses commands from the version control system to obtain the differences between the staged changes. Specifically, the server runs the git diff --cached command to determine the differences between the current working directory and the most recently committed content. By obtaining this difference information, the server can accurately identify the file names and changes required for the next process.

[1172] Filename Parsing

[1173] The server analyzes the changed file names based on the difference information it has obtained. Regular expressions are used for this analysis. By using regular expressions, it is possible to efficiently and accurately list the changed file names from the difference information. The listed file names are used to generate the next commit message.

[1174] Generate a commit message

[1175] The server generates a commit message based on the parsed filenames. The generated message is in the format "Changed files: [filename1], [filename2], ...". This makes it easy to see at a glance who changed which files.

[1176] Emotional engine regulation

[1177] The server uses an emotion engine to recognize the user's emotional state. The emotion engine analyzes the user's input and biometric information (e.g., tone of voice, facial expression data, etc.) to determine the user's emotion. The server adjusts the commit message based on this emotional information. For example, if the user is in a stressful state, the server can add an encouraging comment to the commit message. As a specific example, it can generate an adjusted message such as "Changed files: hello.py, README.md. Keep up the great work!"

[1178] Performing a commit

[1179] The server uses the generated commit message to execute a commit to the version control system, which saves the changes to the repository. The server executes the commit using the git commit -m "generated commit message" command.

[1180] Specific examples

[1181] For example, if a user creates a new "hello.py" file and updates an existing "README.md" file, the following behavior occurs when the system is run with these changes staged in the version control system:

[1182] Diff: The server runs the git diff --cached command to get the diff of the staged changes.

[1183] Filename parsing: The server uses regular expressions to extract "hello.py" and "README.md" from the diff text.

[1184] Generate a commit message: The server generates a message in the format "Changed files: hello.py, README.md".

[1185] Adjustment by emotion engine: The server recognizes the user's emotion and generates an adjusted message, for example, "Changed files: hello.py, README.md. Keep up the great work!" if the user is feeling stressed.

[1186] Perform the commit: The server performs the commit to the version control system using the generated commit message.

[1187] Message notification: The server displays the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[1188] This system automatically generates appropriate commit messages, improving user work efficiency while enabling messages to be adjusted according to emotional fluctuations.

[1189] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1190] Step 1: Get the diff

[1191] The server uses commands from the version control system to get the diff of the staged changes. Specifically, the server runs the git diff --cached command to get the difference between the current working directory and the most recently committed content. The diff information is the input, and the output is the diff data as a comparison result.

[1192] Specific behavior:

[1193] The server runs the git diff --cached command to get the diffs of the changed files, which are temporarily stored in memory.

[1194] Step 2: Parsing the filename

[1195] Analyzes the changed file names based on the difference information obtained from the server. The input is the difference information and the output is a list of changed file names. Regular expressions are used for this analysis.

[1196] Specific behavior:

[1197] The server analyzes the diff information and applies regular expressions to extract the changed filenames, which are organized into a list and stored in memory.

[1198] Step 3: Generate a commit message

[1199] The server generates a commit message based on the parsed filenames. The input is a list of changed filenames, and the output is the commit message. The generated message is in the format "Changed files: [filename1], [filename2], ...".

[1200] Specific behavior:

[1201] The server reads the list of filenames and uses them to construct a commit message in the specified format, which is then stored in memory.

[1202] Step 4: Emotional Engine Adjustment

[1203] The server uses an emotion engine to recognize the user's emotional state. The input is the user's input and biometric information, and the output is a commit message that reflects the user's emotional state. The emotion engine performs analysis and identifies the user's emotion.

[1204] Specific behavior:

[1205] 1. The server launches the emotion engine and collects user input (e.g., keyboard typing speed, mouse movements) and biometric information (e.g., tone of voice, facial expression data).

[1206] 2. The emotion engine analyzes the collected data and determines the user's emotional state.

[1207] 3. The server adjusts the commit message based on this emotional information, for example adding an encouraging message like "Keep up the great work!" if the user is stressed.

[1208] Step 5: Performing a Commit

[1209] The server uses the generated commit message to execute a commit into the version control system. The input is the commit message, and the output is the changes reflected in the repository.

[1210] Specific behavior:

[1211] The server executes the git commit -m "generated commit message" command, saving the changes to the repository. Verify that the commit was successful.

[1212] Step 6: Message Notification

[1213] The server notifies the user with a successful commit message. The input is the status that the commit was successful, and the output is a notification message to the user.

[1214] Specific behavior:

[1215] 1. The server generates a commit success message and sends a notification to the user's device.

[1216] 2. The user will see the message "Committed with message: Changed files: hello.py, README.md. Keep up the great work!"

[1217] (Application example 2)

[1218] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1219] In software development, when properly obtaining the difference between changes and generating commit messages, the process is mechanically performed without considering the user's feelings, which can lead to a problem of reduced work efficiency depending on the user's psychological state. In particular, there is a problem that processing monotonous commit messages under stress reduces motivation, resulting in a decline in work efficiency.

[1220] The specification process by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring differences in changes, means for analyzing the changed data from the acquired differences, means for generating a commit message based on the analyzed data, means for adjusting the commit message using an emotion engine that recognizes the user's emotions, and means for committing to the data management system using the generated commit message. This makes it possible to automatically analyze changes and automatically generate appropriate commit messages, as well as adjust the message according to the user's emotions, thereby improving user work efficiency and the quality of repository management.

[1221] The "means for obtaining the difference of the changes" is a means for detecting and recording the changes newly made in the software repository.

[1222] The "means for analyzing changed data" is a means for automatically analyzing and identifying affected files and data based on the acquired difference information.

[1223] The "means for generating a commit message" is a means for automatically creating a commit message in a format that is easy for a user to understand, based on the analyzed data.

[1224] An "emotion engine" is software or hardware that analyzes a user's facial expressions, voice, input data, etc., and identifies the user's emotional state.

[1225] The "means for adjusting a commit message" refers to a means for appropriately changing the tone and content of the generated commit message depending on the emotional state of the user identified by the emotion engine.

[1226] A "data management system" is a system that primarily manages the versioning of software repositories, and its purpose is to store, manage, and share change histories.

[1227] This invention is a system for supporting software update management for factory robots, in which a server obtains the differences in changes, analyzes the changed data, generates a commit message, recognizes the user's emotions, adjusts the commit message, and commits it.

[1228] The server uses the following hardware and software: The hardware includes a basic server environment, a smartphone, a head-mounted display, a microphone, a camera, etc. The software uses PyGit2 for operating Git repositories, Google Speech Recognition API for voice recognition, EmotionRecognizer for emotion recognition, and gTTS for text-to-speech synthesis.

[1229] The server first retrieves the diffs of the factory robot's software changes from the Git repository, allowing the server to understand what new changes have been made. The diff information is then parsed using regular expressions to automatically identify which files have changed.

[1230] The server then generates a commit message based on the retrieved diff information, which has the format "Modified files: [filename1], [filename2], ..." But the key here is that the server is aware of the user's emotional state and adjusts the message accordingly.

[1231] To recognize the user's emotional state, voice input and facial expression data are used. When the user inputs commands into the microphone, the server converts the voice commands into text data using the Google Speech Recognition API. Furthermore, it uses EmotionRecognizer to analyze the user's emotions and adjusts the content of the commit message depending on whether the user is in a stressful or positive state. For example, if the user is in a stressful state, a message such as "Good luck, good job!" is added.

[1232] Finally, the server executes the commit to the Git repository using the generated commit message. After the commit process is successful, the result is notified by voice. The server uses gTTS to synthesize the commit result and notify the user.

[1233] As a concrete example, consider the case where a user modifies "controller.py" and "sensor_data.py" while updating a robot's software. If the user speaks into the microphone and says "Please commit," the system recognizes the voice and determines that the user is stressed. In this case, it generates an encouraging message such as "Modified files: controller.py, sensor_data.py. Keep up the great work!" and executes the commit.

[1234] An example of a prompt is "Get the diff to commit and analyze the changed file names. Analyze the user's sentiment from the voice input and adjust the commit message." For example, it is executed by the voice input "Please commit."

[1235] In this way, the present invention realizes automatic analysis of changes in software management of factory robots, generation of appropriate commit messages, and adjustment of messages according to user emotions, thereby improving work efficiency and management quality.

[1236] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1237] Step 1:

[1238] The server retrieves the diff of changes from the Git repository, specifically by running the git diff --cached command to retrieve the staged changes. The input is the Git repository with the staged changes, and the output is the diff information.

[1239] Step 2:

[1240] The server analyzes the changed data based on the difference information it has acquired. It analyzes the difference information using regular expressions and extracts the changed file names. The input is the difference information, and the output is a list of changed file names.

[1241] Step 3:

[1242] The server generates a commit message based on the parsed file names. For example, if the changed file names are "controller.py" and "sensor_data.py", it generates a message of the form "Changed files: controller.py, sensor_data.py". The input is a list of changed file names, and the output is a basic commit message.

[1243] Step 4:

[1244] The user inputs voice instructions into the microphone to adjust the commit message, and the server converts the speech to text data using the Google Speech Recognition API. The input is the user's voice instructions, and the output is text data.

[1245] Step 5:

[1246] The server identifies the user's emotional state based on the text data of the voice instructions. It uses EmotionRecognizer to analyze the text data and determine whether the user is in a stressful or positive state. The input is the text data of the voice instructions, and the output is the user's emotional state.

[1247] Step 6:

[1248] The server adjusts the commit message according to the perceived emotional state, for example, if the user is stressed, it adds an encouraging message such as "Keep up the good work, good job!" The input is a basic commit message and the user's emotional state, and the output is the adjusted commit message.

[1249] Step 7:

[1250] The server executes the commit to the Git repository using the adjusted commit message. It executes the git commit command using the generated commit message. The input is the adjusted commit message, and the output is a notification of the success of the commit operation.

[1251] Step 8:

[1252] The server notifies the user of the result of the commit process. It uses gTTS to synthesize the commit result and notifies the user by voice. The input is a notification of the success of the commit process, and the output is a voice notification of the commit result.

[1253] In this way, the server automatically analyzes changes in software management of factory robots, automatically generates commit messages, adjusts messages according to the user's emotions, and provides audio notification of the commit contents.

[1254] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

[1255] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1256] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1257] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1258] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1259] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1260] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1261] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1262] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1263] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1264] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1265] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1266] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1267] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1268] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1269] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1270] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1271] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1272] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1273] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1274] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1275] The following is further disclosed regarding the above embodiment.

[1276] (Claim 1)

[1277] A means of obtaining the difference of the changes;

[1278] A means of analyzing the changed file names from the obtained diff;

[1279] A means for generating a commit message based on the parsed filename;

[1280] A means for committing to a version control system using the generated commit message;

[1281] A system including:

[1282] (Claim 2)

[1283] 2. The system according to claim 1, further comprising means for notifying that there is no change if the acquired difference does not exist.

[1284] (Claim 3)

[1285] 2. The system according to claim 1, wherein the acquired differences are analyzed using regular expressions.

[1286] "Example 1"

[1287] (Claim 1)

[1288] A way to get a diff of the staged changes;

[1289] A means for analyzing the changed file names from the acquired differences using regular expressions;

[1290] A means to generate a commit message of the form "Changed files: [filename]" based on the parsed filenames; and

[1291] A means for committing to a version control system using the generated commit message;

[1292] A system including:

[1293] (Claim 2)

[1294] 2. The system according to claim 1, further comprising means for notifying that there is no change if the acquired difference does not exist.

[1295] (Claim 3)

[1296] 10. The system of claim 1, further comprising: means for optimizing the generated commit messages using a generative AI model.

[1297] "Application Example 1"

[1298] (Claim 1)

[1299] A means of obtaining the difference of the changes;

[1300] A means of analyzing the changed file names from the obtained diff;

[1301] A means for generating a commit message based on the parsed filename;

[1302] A means for committing to a version control system using the generated commit message;

[1303] a means for storing the generated commit message in a repository as a change to the software installed in the control unit of the factory robot;

[1304] A system including:

[1305] (Claim 2)

[1306] 2. The system according to claim 1, further comprising means for notifying that there is no change if the acquired difference does not exist.

[1307] (Claim 3)

[1308] The system according to claim 1, characterized in that the generated commit message is used to perform software update management for factory robots.

[1309] "Example 2: Combining Emotion Engines"

[1310] (Claim 1)

[1311] A means of obtaining the difference of the changes;

[1312] A means of analyzing the changed file names from the obtained diff;

[1313] A means for generating a commit message based on the parsed filename;

[1314] a means for recognizing a user's emotional state and adjusting the commit message;

[1315] A means for committing to a version control system using the generated commit message;

[1316] A system including:

[1317] (Claim 2)

[1318] 2. The system of claim 1, further comprising means for notifying that there is no change if the acquired difference does not exist.

[1319] (Claim 3)

[1320] 2. The system according to claim 1, wherein the acquired differences are analyzed using regular expressions.

[1321] "Application example 2 when combining emotion engines"

[1322] (Claim 1)

[1323] A means of obtaining the difference of the changes;

[1324] A means for analyzing the changed data from the obtained difference;

[1325] means for generating a commit message based on the parsed data;

[1326] a means for adjusting the commit message using an emotion engine that recognizes the emotion of the user;

[1327] means for committing to a data management system using the generated commit message;

[1328] A system including:

[1329] (Claim 2)

[1330] 2. The system according to claim 1, further comprising means for notifying that there is no change if the acquired difference does not exist.

[1331] (Claim 3)

[1332] 2. The system according to claim 1, wherein the acquired differences are analyzed using regular expressions. [Explanation of symbols]

[1333] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means of obtaining the difference of the changes; A means of analyzing the changed file names from the obtained diff; A means for generating a commit message based on the parsed filename; A means for committing to a version control system using the generated commit message; A system including:

2. 2. The system according to claim 1, further comprising means for notifying that there is no change if the acquired difference does not exist.

3. 2. The system according to claim 1, wherein the acquired differences are analyzed using regular expressions.

Images