pilot.linkstec 0.0.1__py3-none-any.whl

pilot/config/config_reader.py

@@ -0,0 +1,89 @@
+import configparser
+import os
+import inspect
+from dataclasses import dataclass
+from typing import List
+
+@dataclass
+class ConfigDTO:
+    work_space: str
+    threads: int
+    project: str
+    steps: list[str]
+    skipsteps: list[str]
+
+
+
+class ConfigReader:
+    def __init__(self, filename = None):
+        filepath = None
+        if filename is None:
+            filepath = self.find_config_path()
+
+        if filename is not None:
+            cwd = os.getcwd()
+            filepath = os.path.join(cwd, 'config', filename)
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(f"Configuration file not found: {filepath}")
+
+        self.config = configparser.ConfigParser()
+        self.config.optionxform = str
+
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()
+        if not content.lstrip().startswith('['):
+            content = '[DEFAULT]\n' + content
+        self.config.read_string(content)
+
+    @classmethod
+    def find_config_path(cls):
+        cwd = os.getcwd()
+        candidate_path = os.path.join(cwd, 'config', 'control.properties')
+        if os.path.exists(candidate_path):
+            return candidate_path
+
+        stack = inspect.stack()
+        for frame in stack:
+            caller_file = frame.filename
+            caller_dir = os.path.dirname(os.path.abspath(caller_file))
+            possible_path = os.path.abspath(os.path.join(caller_dir, '..', '..', 'config', 'control.properties'))
+            if os.path.exists(possible_path):
+                return possible_path
+
+        base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+        fallback_path = os.path.join(base_dir, 'config', 'control.properties')
+        if os.path.exists(fallback_path):
+            return fallback_path
+
+        raise FileNotFoundError("control.properties not found in expected locations")
+
+    def get(self, section, option, fallback=None, cast_type=str):
+        try:
+            if cast_type == bool:
+                return self.config.getboolean(section, option)
+            elif cast_type == int:
+                return self.config.getint(section, option)
+            elif cast_type == float:
+                return self.config.getfloat(section, option)
+            else:
+                return self.config.get(section, option)
+        except (configparser.NoSectionError, configparser.NoOptionError):
+            return fallback
+
+    def get_dto(self) -> ConfigDTO:
+        input_path = self.get('DEFAULT', 'input_path', fallback='.')
+        work_space = self.get('DEFAULT', 'work_space', fallback='.')
+        threads = int(self.get('DEFAULT', 'threads', fallback=1))
+        project = self.get('DEFAULT', 'project', fallback='')
+        steps_str = self.get('DEFAULT', 'steps', fallback='')
+        steps = [s.strip() for s in steps_str.split(',')] if steps_str else []
+        skipsteps_str = self.get('DEFAULT', 'skipsteps', fallback='')
+        skipsteps = [s.strip() for s in skipsteps_str.split(',')] if skipsteps_str else []
+
+        return ConfigDTO(
+            work_space=work_space,
+            threads=threads,
+            project=project,
+            steps=steps,
+            skipsteps=skipsteps
+        )

pilot/control/control_interface.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+class ControlInterface(ABC):
+    @abstractmethod
+    def run(self):
+        pass

pilot/control/impl/base_controller.py

@@ -0,0 +1,29 @@
+from concurrent.futures import ThreadPoolExecutor
+
+from generater.vertexai import VertexAISingleton
+from src.pilot.control.control_interface import ControlInterface
+from src.pilot.unit.impl.base_unit import BaseUnit
+from src.pilot.config.config_reader import ConfigReader
+
+
+class BaseController(ControlInterface):
+
+    def __init__(self):
+        vertexai: VertexAISingleton = VertexAISingleton.get_instance()
+
+    def _init_unit(self):
+        return BaseUnit()
+
+    def run(self):
+        import time
+        config_dto = ConfigReader().get_dto()
+        def worker():
+            unit = self._init_unit()
+            unit.run()
+        with ThreadPoolExecutor(max_workers=config_dto.threads) as executor:
+            futures = []
+            for _ in range(config_dto.threads):
+                futures.append(executor.submit(worker))
+                time.sleep(0.2)
+            for future in futures:
+                future.result()

pilot/conver/converfileEncodding.py

@@ -0,0 +1,77 @@
+import subprocess
+import sys
+import os
+
+def nkf_convert(file_path, nkf_args):
+    """
+    nkf を使ってファイルの文字コード変換を行う
+
+    :param file_path: 変換対象のファイルパス
+    :param nkf_args: nkf に渡す引数のリスト（例: ['-w']）
+    """
+    # nkfコマンドの引数にファイルパスを追加
+    #cmd = ['nkf'] + nkf_args + [file_path]
+
+    cmd = ['nkf32'] + nkf_args + file_path
+
+
+    try:
+        # nkfを実行し標準出力を取得
+        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+        print(f"nkfの実行完了しました: {file_path}")
+    except subprocess.CalledProcessError as e:
+        print(f"nkfの実行でエラーが発生しました: {e.stderr.decode()}", file=sys.stderr)
+        return None
+
+    # nkfの変換結果（バイト列）を返す
+    return result.stdout
+
+
+#if __name__ == "__main__":
+    # 処理対象のルートフォルダパスを指定（適宜変更してください）
+#    root_folder = r"d:\work2\src"
+#    nkf_convert(root_folder, ['-v'])
+
+
+
+#if __name__ == "__main__":
+#   if len(sys.argv) < 3:
+    #        print(f"使い方: python {sys.argv[0]} <ファイルパス> <nkf引数...>", file=sys.stderr)
+    #    print(f"例: python {sys.argv[0]} test.txt -w --overwrite", file=sys.stderr)
+    #    sys.exit(1)
+
+#    file_path = [r"D:\test\CHKCONST.cpy"]
+#    nkf_args = ['-w','--overwrite']
+    #nkf_args = ['-g']
+#    output = nkf_convert(file_path, nkf_args)
+
+
+if __name__ == "__main__":
+
+
+    target_dir = r'D:\work\fullsource'
+    nkf_args = ['-w', '--overwrite']
+    #extensions = (
+    #    '.cfc', '.cfm', '.cob', '.cobol', '.cpy', '.csh', '.css', '.ctl',
+    #    '.htm', '.html', '.js', '.sh', '.sql', '.tpl', '.txt'
+    #)
+    extensions = ('.cnd','.cng','int')
+    for root, dirs, files in os.walk(target_dir):
+        for file in files:
+            if file.lower().endswith(extensions):
+                filepath = os.path.join(root, file)
+                output = nkf_convert([filepath], nkf_args)
+
+
+    #if output is not None:
+        # 結果を標準出力にバイナリのまま書き出す場合
+        # sys.stdout.buffer.write(output)
+
+        # あるいはUTF-8等に応じてデコードして表示する場合
+        # 一旦utf-8デコードを試みる例（必要に応じて変更してください）
+    #    try:
+    #        decoded_output = output.decode('utf-8')
+    #        print(decoded_output)
+    #    except UnicodeDecodeError:
+    #        print("utf-8へのデコードに失敗しました。バイナリデータとして出力します。", file=sys.stderr)
+#        sys.stdout.buffer.write(output)

pilot/conver/nkf_converter.py

@@ -0,0 +1,28 @@
+import subprocess
+import sys
+
+class NkfConverter:
+    def __init__(self, nkf_args=None):
+        """
+        コンストラクタ
+        :param nkf_args: nkf に渡す引数のリスト（例: ['-w', '--overwrite']）
+                         指定しない場合はデフォルト値を使用
+        """
+        if nkf_args is None:
+            nkf_args = ['-w', '--overwrite']
+        self.nkf_args = nkf_args
+
+    def convert(self, file_path):
+        """
+        nkf を使ってファイルの文字コード変換を行う
+        :param file_path: 変換対象のファイルパス
+        :return: nkfの変換結果のバイト列、失敗したらNone
+        """
+        cmd = ['nkf32'] + self.nkf_args + [file_path]
+        try:
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+            print(f"nkfの実行完了しました: {file_path}")
+        except subprocess.CalledProcessError as e:
+            print(f"nkfの実行でエラーが発生しました: {e.stderr.decode()}", file=sys.stderr)
+            return None
+        return result.stdout

pilot/generater/vertexai.py

@@ -0,0 +1,66 @@
+import threading
+from typing import Dict, Any, Optional
+
+import tiktoken
+from vertexai.preview.generative_models import GenerativeModel, ChatSession
+from transformers import AutoTokenizer
+import os
+
+class VertexAISingleton:
+    _instance: Optional['VertexAISingleton'] = None
+    _lock = threading.Lock()
+    _tokenizer_cache = {}
+    encoding = None
+
+    def __new__(cls, model_name: str = "gemini-2.5-pro"):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(VertexAISingleton, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, model_name: str = "gemini-2.5-pro"):
+        if not self._initialized:
+            with self._lock:
+                if not self._initialized:
+                    self.model = GenerativeModel(model_name)
+                    os.environ["TIKTOKEN_CACHE_DIR"] = r"D:\api"
+                    self.encoding = tiktoken.get_encoding("cl100k_base")
+                    self._initialized = True
+
+    def generate_content(self, prompt: str) -> Dict[str, Any]:
+        """複数スレッドから安全に呼び出し可能"""
+        try:
+            response = self.model.generate_content(prompt)
+            return {
+                "prompt": prompt,
+                "response": response.text,
+                "success": True,
+                "error": None
+            }
+        except Exception as e:
+            return {
+                "prompt": prompt,
+                "response": None,
+                "success": False,
+                "error": str(e)
+            }
+
+    def start_chat(self) -> ChatSession:
+        """新しいチャットセッションを開始"""
+        return self.model.start_chat()
+
+    def count_tokens(self, text: str) -> int:
+        """与えられたテキストのトークン数を返す（bert-base-uncasedのみ使用）"""
+        try:
+            tokens = self.encoding.encode(text)
+            return len(tokens)
+        except Exception as e:
+            print(f"トークン計算失敗: {e}")
+            return 0
+
+    @classmethod
+    def get_instance(cls, model_name: str = "gemini-2.5-pro") -> 'VertexAISingleton':
+        """インスタンスを取得"""
+        return cls(model_name)

pilot/job/impl/base_job.py

@@ -0,0 +1,288 @@
+import os
+import shutil
+
+from pilot.job.job_interface import JobInterface
+from pilot.config.config_reader import ConfigReader
+
+
+class BaseJob(JobInterface):
+    def __init__(self):
+        self.config_dto = ConfigReader().get_dto()
+        self._current_step = None
+        self._file_path = None
+        self._step_index = None
+        self._next_step = None
+        self._next_step_file_path = None
+        self._content = None
+
+    @property
+    def current_step(self):
+        return self._current_step
+
+    @current_step.setter
+    def current_step(self, value):
+        self._current_step = value
+
+    @property
+    def file_path(self):
+        return self._file_path
+
+    @file_path.setter
+    def file_path(self, value):
+        self._file_path = value
+        self._content = None  # ファイルパスが変わったらキャッシュクリア
+
+    @property
+    def step_index(self):
+        return self._step_index
+
+    @step_index.setter
+    def step_index(self, value):
+        self._step_index = value
+        self._next_step = None  # step_indexが変わったらnext_stepをリセット
+
+    @property
+    def next_step(self):
+        if self._next_step is None and self._step_index is not None:
+            steps_list = self.config_dto.steps
+            if self._step_index + 1 < len(steps_list):
+                self._next_step = steps_list[self._step_index + 1]
+            else:
+                self._next_step = None
+        return self._next_step
+
+    @next_step.setter
+    def next_step(self, value):
+        self._next_step = value
+
+
+    @property
+    def current_trg_file_path(self):
+        return self._trg_file_path
+
+    @current_trg_file_path.setter
+    def current_trg_file_path(self, value):
+        self._trg_file_path = value
+
+
+
+
+    def run(self):
+        pass
+
+    def get_file_content(self):
+        if self._content is None and self._file_path:
+            with open(self._file_path, 'r', encoding='utf-8') as f:
+                self._content = f.read()
+        return self._content
+
+    def get_current_step_relative_path(self):
+        if not self._file_path:
+            return self._file_path
+
+        try:
+            base_dir = os.path.join(self.config_dto.work_space, self.current_step)
+            return os.path.relpath(self._file_path, base_dir)
+        except ValueError:
+            return self._file_path
+
+    def get_current_step_count(self):
+        if not self._file_path:
+            return self.config_dto.work_space
+        try:
+            relative_path = self.get_current_step_relative_path()
+            return os.path.relpath(self.config_dto.work_space, relative_path)
+        except ValueError:
+            return self.config_dto.work_space
+
+    def _copy_file_to_step_dir(self, src_path, base_dir, step_dir):
+        """指定したsrc_pathをbase_dirからの相対パスをごとstep_dir配下にコピーする。
+           すでにコピー先に同名ファイルがあればNoneを返し、存在しなければコピー先ファイルパスを返す。
+        """
+        if not src_path:
+            return None
+
+        rel_path = os.path.relpath(os.path.dirname(src_path), base_dir)
+        dest_dir = os.path.join(step_dir, rel_path)
+        base_file_name = os.path.basename(src_path)
+        dest_file_path = os.path.join(dest_dir, base_file_name)
+
+        if os.path.exists(dest_file_path):
+            self._next_step_file_path = dest_file_path
+            return None
+
+        os.makedirs(dest_dir, exist_ok=True)
+        shutil.copy(src_path, dest_file_path)
+        self._next_step_file_path = dest_file_path
+        return dest_file_path
+
+
+    def copy_current_file_to_next_step(self):
+        if not self._file_path or not self.next_step:
+            return None
+        base_dir = os.path.join(self.config_dto.work_space, self.current_step)
+        step_dir = os.path.join(self.config_dto.work_space, self.next_step)
+        return self._copy_file_to_step_dir(self._file_path, base_dir, step_dir)
+
+
+    # 共通化メソッド
+    def _create_next_step_trigger_file(self, ext):
+        if self._next_step_file_path:
+            trg_file = self._next_step_file_path + ".trg"
+            end_file = self._next_step_file_path + ".end"
+            begin_file = self._next_step_file_path + ".begin"
+            target_file = self._next_step_file_path + ext
+            if not (os.path.exists(trg_file) or os.path.exists(end_file) or os.path.exists(begin_file)):
+                open(target_file, 'w', encoding='utf-8').close()
+            return trg_file
+        return None
+
+    def create_next_step_todo_trg_file(self):
+        return self._create_next_step_trigger_file(".trg")
+
+    def create_next_step_end_trg_file(self):
+        return self._create_next_step_trigger_file(".end")
+
+    def create_next_step_begin_trg_file(self):
+        return self._create_next_step_trigger_file(".begin")
+
+
+    def change_current_trg_to_end(self):
+        if os.path.exists(self.current_trg_file_path):
+            file_path, file_extension = os.path.splitext(self.current_trg_file_path)
+            if file_extension == ".trg" or file_extension == ".begin":
+                try:
+                    os.rename(self.current_trg_file_path, file_path + ".end")
+                    return True
+                except Exception:
+                    # 例外が発生した場合は False を返す
+                    print("!!!!!!!!!!!!!!!!!!!!change_current_trg_to_end erro")
+                    return False
+        # trgファイルが存在しなければ何もしないので、そのままreturn
+        return False
+
+    def change_current_trg_to_begin(self):
+        if os.path.exists(self.current_trg_file_path):
+            file_path, file_extension = os.path.splitext(self.current_trg_file_path)
+            if file_extension == ".trg":
+                try:
+                    os.rename(self.current_trg_file_path, file_path + ".begin")
+                    self.current_trg_file_path = os.path.join(file_path + ".begin")
+                    return True
+                except Exception:
+                    # 例外が発生した場合は False を返す
+                    return False
+        return False
+
+    def copy_input_file_to_next_step(self, input_file_path):
+            """
+            input_file_pathで指定されたファイルを、next stepフォルダにコピーする。
+            コピー先に同名ファイルがあればNone、存在しなければコピー先ファイルパスを返す。
+            """
+            if not input_file_path or not self.next_step:
+                return None
+            base_dir = os.path.join(self.config_dto.work_space, self.current_step)
+            step_dir = os.path.join(self.config_dto.work_space, self.next_step)
+            return self._copy_file_to_step_dir(input_file_path, base_dir, step_dir)
+
+    def create_next_step_todo_trg_file_from_input(self, input_file_path):
+        """
+        input_file_pathで指定されたファイルをnext stepフォルダにコピーし、.trgファイルを生成する。
+        ファイルが既に存在する場合でも.trgファイルの作成を試行する。
+        """
+        if not input_file_path or not self.next_step:
+            return None
+
+        # ファイルをコピー（既存の場合はNoneが返される）
+        copied_file_path = self.copy_input_file_to_next_step(input_file_path)
+
+        # コピーが成功しなかった場合でも、対象ファイルパスを取得
+        if not copied_file_path:
+            base_dir = os.path.join(self.config_dto.work_space, self.current_step)
+            step_dir = os.path.join(self.config_dto.work_space, self.next_step)
+            rel_path = os.path.relpath(os.path.dirname(input_file_path), base_dir)
+            dest_dir = os.path.join(step_dir, rel_path)
+            base_file_name = os.path.basename(input_file_path)
+            copied_file_path = os.path.join(dest_dir, base_file_name)
+
+        # .trgファイルを作成
+        trg_file = copied_file_path + ".trg"
+        end_file = copied_file_path + ".end"
+        begin_file = copied_file_path + ".begin"
+
+        if not (os.path.exists(trg_file) or os.path.exists(end_file) or os.path.exists(begin_file)):
+            # 空ファイルとして.trgファイルを生成
+            open(trg_file, 'w', encoding='utf-8').close()
+            return trg_file
+
+        return None
+
+    def create_current_step_end_trg_file_from_input(self, input_file_path):
+        """
+        input_file_pathで指定されたファイルに対して.endファイルを生成する。
+        """
+        if not input_file_path:
+            return None
+
+        trg_file = input_file_path + ".trg"
+        end_file = input_file_path + ".end"
+        begin_file = input_file_path + ".begin"
+
+        # マーカーファイルが存在しない場合のみ.endファイルを作成
+        if not (os.path.exists(trg_file) or os.path.exists(end_file) or os.path.exists(begin_file)):
+            # 空ファイルとして.endファイルを生成
+            open(end_file, 'w', encoding='utf-8').close()
+            return end_file
+        return None
+
+
+    def create_trg_file_in_file_path_dir(self, file_name):
+        """
+        file_pathのディレクトリ配下に指定されたファイル名の.trgファイルを作成する。
+        既に.trg, .end, .beginファイルが存在する場合は何もしない。
+        """
+        if not self._file_path or not file_name:
+            return None
+        dir_path = os.path.dirname(self._file_path)
+        base_path = os.path.join(dir_path, file_name)
+        trg_file = base_path + ".trg"
+        end_file = base_path + ".end"
+        begin_file = base_path + ".begin"
+        if not (os.path.exists(trg_file) or os.path.exists(end_file) or os.path.exists(begin_file)):
+            # 空ファイルとして.trgファイルを生成
+            open(trg_file, 'w', encoding='utf-8').close()
+            return trg_file
+        return None
+
+    def get_work_space(self):
+        """
+        config_dtoからwork_spaceを取得するメソッド
+        """
+        return self.config_dto.work_space
+
+    def copy_file_todo_trg_to_next_step(self, result_file):
+        self.create_current_step_end_trg_file_from_input(result_file)
+        next_step_file = self.copy_input_file_to_next_step(result_file)
+        self.create_next_step_todo_trg_file_from_input(next_step_file)
+
+    def change_trg_file_to_end_in_file(self, file_name):
+        """
+        file_pathのディレクトリ配下に指定されたファイル名の.trgまたは.beginファイルが存在すれば、.endにリネームする。
+        成功時 True、失敗時 False を返す。
+        """
+        if not self._file_path or not file_name:
+            return False
+        dir_path = os.path.dirname(self._file_path)
+        base_path = os.path.join(dir_path, file_name)
+        trg_file = base_path + ".trg"
+        begin_file = base_path + ".begin"
+        end_file = base_path + ".end"
+        # .trgまたは.beginが存在すれば.endにリネーム
+        if os.path.exists(begin_file):
+            try:
+                os.rename(trg_file, end_file)
+                return True
+            except Exception:
+                print(f"change_trg_file_to_end_in_file error: {trg_file}")
+                return False
+        return False

pilot/job/job_interface.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+class JobInterface(ABC):
+    @abstractmethod
+    def run(self):
+        pass

pilot/splitters/cobolsplitter.py

@@ -0,0 +1,128 @@
+import re
+import os
+import logging
+
+class CobolSplitter:
+    def __init__(self, input_file):
+        self.input_file = input_file
+        self.identification_div = []
+        self.environment_div = []
+        self.data_div = []
+        self.procedure_div = []  # list of tuples: (line_text, line_number)
+        self.paragraphs = {}
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s [%(levelname)s] %(message)s"
+        )
+        logging.debug(f"Initialized CobolSplitter for file: {input_file}")
+    @staticmethod
+    def normalize_whitespace(s):
+        return re.sub(r'\s+', ' ', s).strip().upper()
+
+    @classmethod
+    def line_starts_with_division(cls, line, division_name):
+        line_norm = cls.normalize_whitespace(line)
+        division_norm = cls.normalize_whitespace(division_name)
+        return line_norm.startswith(division_norm)
+
+    def read_file(self):
+        logging.debug(f"Reading file: {self.input_file}")
+        with open(self.input_file, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        div = None
+        for idx, line in enumerate(lines, 1):  # 行番号は1始まり
+            if self.line_starts_with_division(line, "IDENTIFICATION DIVISION"):
+                div = "IDENTIFICATION"
+                logging.debug(f"Found IDENTIFICATION DIVISION at line {idx}")
+            elif self.line_starts_with_division(line, "ENVIRONMENT DIVISION"):
+                div = "ENVIRONMENT"
+                logging.debug(f"Found ENVIRONMENT DIVISION at line {idx}")
+            elif self.line_starts_with_division(line, "DATA DIVISION"):
+                div = "DATA"
+                logging.debug(f"Found DATA DIVISION at line {idx}")
+            elif self.line_starts_with_division(line, "PROCEDURE DIVISION"):
+                div = "PROCEDURE"
+                logging.debug(f"Found PROCEDURE DIVISION at line {idx}")
+            elif line.strip() == ".":
+                div = None
+                logging.debug(f"Division end at line {idx}")
+
+            if div == "IDENTIFICATION":
+                self.identification_div.append(line)
+            elif div == "ENVIRONMENT":
+                self.environment_div.append(line)
+            elif div == "DATA":
+                self.data_div.append(line)
+            elif div == "PROCEDURE":
+                self.procedure_div.append( (line, idx) )  # タプルで行テキストと行番号を保持
+            else:
+                self.identification_div.append(line)
+        logging.debug("Finished reading and splitting divisions.")
+
+    def split_paragraphs(self):
+        logging.debug("Splitting PROCEDURE DIVISION into paragraphs.")
+        procedure_lines = self.procedure_div[:]
+        if procedure_lines and self.line_starts_with_division(procedure_lines[0][0], "PROCEDURE DIVISION"):
+            procedure_lines.pop(0)
+
+        para_header_re = re.compile(r"^\s*([A-Z0-9\-]+)\.\s*$", re.I)
+
+        current_para = None
+        current_lines = []
+
+        for line, lineno in procedure_lines:
+            m = para_header_re.match(line)
+            if m:
+                if current_para:
+                    self.paragraphs[current_para] = current_lines
+                    logging.debug(f"Paragraph '{current_para}' ends at line {lineno}")
+                current_para = m.group(1)
+                current_lines = [(line, lineno)]
+                logging.debug(f"Paragraph '{current_para}' starts at line {lineno}")
+            else:
+                if current_para:
+                    current_lines.append((line, lineno))
+                else:
+                    current_para = "MAIN"
+                    current_lines = [(line, lineno)]
+        if current_para:
+            self.paragraphs[current_para] = current_lines
+            logging.debug(f"Paragraph '{current_para}' ends at last line.")
+        logging.debug(f"Total paragraphs found: {len(self.paragraphs)}")
+
+    def write_files(self):
+        logging.debug("Writing split paragraphs to files.")
+        created_files = []
+
+        base_name = os.path.splitext(os.path.basename(self.input_file))[0]
+        input_dir = os.path.dirname(self.input_file)
+        outdir = os.path.join(input_dir, base_name)
+        os.makedirs(outdir, exist_ok=True)
+        logging.debug(f"Output directory created: {outdir}")
+
+        for para, lines_para in self.paragraphs.items():
+            # パラグラフの開始行番号を取得
+            start_line = lines_para[0][1] if lines_para else 0
+            outfname = os.path.join(outdir, f"{base_name}_{para}_{start_line}.cbl")
+
+            with open(outfname, "w", encoding="utf-8") as f:
+                # パラグラフの内容のみを出力（行番号コメントなし）
+                for line, lineno in lines_para:
+                    f.write(line)
+                    if not line.endswith("\n"):
+                        f.write("\n")
+
+            created_files.append(outfname)
+            logging.info(f"Created: {outfname}")
+
+        logging.debug("All paragraph files written.")
+        return created_files
+
+    def run(self):
+        logging.info("CobolSplitter run started.")
+        self.read_file()
+        self.split_paragraphs()
+        created_files = self.write_files()
+        logging.info("CobolSplitter run finished.")
+        return created_files

pilot/unit/impl/base_unit.py

@@ -0,0 +1,39 @@
+import os
+
+from src.pilot.unit.unit_interface import UnitInterface
+from src.pilot.job.impl.base_job import BaseJob
+from src.pilot.config.config_reader import ConfigReader
+
+class BaseUnit(UnitInterface):
+    config_dto = None
+    joblist = []
+
+    def __init__(self):
+        self.config_dto  = ConfigReader().get_dto()
+
+
+    def _init_job(self,step):
+        return BaseJob()
+
+    def run(self):
+        steps = self.config_dto.steps
+        skipsteps = self.config_dto.skipsteps
+        for index, step in enumerate(steps):
+            if step in skipsteps:
+                continue
+            self._run_jobs_in_step_dir(self.config_dto.work_space+ "/" +step,step,index)
+
+    def _run_jobs_in_step_dir(self, current_step_dir, step,index):
+        for dirpath, _, filenames in os.walk(current_step_dir):
+            for filename in filenames:
+                file_path = os.path.join(dirpath, filename)
+                job = self._init_job(step)
+                job.current_step = step
+                job.step_index = index
+                job.file_path = file_path
+                if self.job_need_run(job,filename,index):
+                    job.run()
+
+
+    def job_need_run(self, job:BaseJob,filename: str,index):
+        return True

pilot/unit/unit_interface.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+class UnitInterface(ABC):
+    @abstractmethod
+    def run(self):
+        pass
+
+    def job_not_run(self):
+        pass
+

pilot/util/files.py

@@ -0,0 +1,45 @@
+import os
+import csv
+
+class FileUtil:
+    @staticmethod
+    def exists(path: str) -> bool:
+        return os.path.exists(path)
+
+    @staticmethod
+    def read(path: str, encoding: str = "utf-8") -> str:
+        with open(path, "r", encoding=encoding) as f:
+            return f.read()
+
+    @staticmethod
+    def write(path: str, data: str, encoding: str = "utf-8") -> None:
+        with open(path, "w", encoding=encoding) as f:
+            f.write(data)
+
+    @staticmethod
+    def export_files_to_csv(folder: str, csv_path: str) -> None:
+        import re
+        rows = []
+        max_depth = 0
+        file_infos = []
+        for root, _, files in os.walk(folder):
+            for file in files:
+                rel_path = os.path.relpath(os.path.join(root, file), folder)
+                parts = rel_path.split(os.sep)
+                file_infos.append((parts, rel_path, root))
+                if len(parts) > max_depth:
+                    max_depth = len(parts)
+        headers = ["No", "file", "ext", "folder_rel_path", "prefix_before_number"] + [f"fold{i + 1}" for i in range(max_depth - 1)]
+        for idx, (parts, rel_path, folder_full_path) in enumerate(file_infos, 1):
+            file_name = parts[-1]
+            ext = os.path.splitext(file_name)[1][1:]
+            folders = parts[:-1]
+            folder_rel_path = os.path.relpath(folder_full_path, folder)
+            match = re.match(r"([^\d]*)(\d.*)?", file_name)
+            prefix_before_number = match.group(1) if match and match.group(2) else ""
+            row = [idx, file_name, ext, folder_rel_path, prefix_before_number] + folders + [""] * (max_depth - 1 - len(folders))
+            rows.append(row)
+        with open(csv_path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            writer.writerow(headers)
+            writer.writerows(rows)

pilot_linkstec-0.0.1.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: pilot.linkstec
+Version: 0.0.1
+Summary: pilot of the ship, a tool for managing and deploying Python projects.
+Author-email: wanglr <wanglr1980@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nighter1980/pilot
+Project-URL: Issues, https://github.com/nighter1980/pilot/issues
+Keywords: python,project management,deployment
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pilot
+
+This is a simple example package. You can use
+to write your content.

pilot_linkstec-0.0.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+pilot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/config/config_reader.py,sha256=RL9925CIjKyimvcspzmZkPzJUJe6z28cfz5nGhZ3g3k,3308
+pilot/control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/control/control_interface.py,sha256=zGv380oQgAKPAIHDHeFdPYzhj2Ngo2T66NWlNloA7vY,124
+pilot/control/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/control/impl/base_controller.py,sha256=wAQTBFk9_bPFnxXiAOw0Au1pGeZvI7uHM2yde9TJTM4,965
+pilot/conver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/conver/converfileEncodding.py,sha256=UqjcWO0bzkuTRHLEWrWJkeo3p-P7WuYE7jFKveyPekA,2781
+pilot/conver/nkf_converter.py,sha256=JqgThmXcdnTGMsLIHUEwe8sc0VGMqDaKCIQTg-UE3WE,1148
+pilot/generater/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/generater/vertexai.py,sha256=P56h5Y_frWzBVLgIg_cs1gu3o9rhX8FyeD8EGe6RJZ8,2393
+pilot/job/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/job/job_interface.py,sha256=LL0hfuFfnKnkpQD99jv1hkaAIAFM-JJPrX3PFxN6O_A,120
+pilot/job/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/job/impl/base_job.py,sha256=1ogh6Ge6qH7gOM5I4dV58xu4NH5gK6-9LYzGHk_Woyc,11701
+pilot/splitters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/splitters/cobolsplitter.py,sha256=oPwxKRjA7TyXWaWV3jdy59lJZy1mRn6yxD9ivqFYCuY,5461
+pilot/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/unit/unit_interface.py,sha256=fE8N4h_rZU-dWLHy9o0EE3yyErGmRyIuGUDb-zqe7qo,167
+pilot/unit/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/unit/impl/base_unit.py,sha256=SiyByVtxflRz91E-LHdjkX9Qrs_0NNNjIXoaDjbF2ww,1276
+pilot/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pilot/util/files.py,sha256=v9uzfzo3Aq4xgnUIASEZeBJoA2nD9Qz_EA3P-FwzGFQ,1896
+pilot_linkstec-0.0.1.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+pilot_linkstec-0.0.1.dist-info/METADATA,sha256=-WkAak-d4m4-LPY0No1WQeyCVih39c_VAXDgzKsrHjE,678
+pilot_linkstec-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pilot_linkstec-0.0.1.dist-info/top_level.txt,sha256=BijnVJdXnIPxxx3s60M848seL4Z12gNUPod6KPJxK9c,6
+pilot_linkstec-0.0.1.dist-info/RECORD,,

pilot_linkstec-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pilot_linkstec-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pilot_linkstec-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pilot